TEST_F(TesteLista, RetiraObj) {
Objeto obj0(20);
Objeto obj1(10);
Objeto obj2(40);
lobj.adiciona(obj0);
lobj.adiciona(obj1);
lobj.adiciona(obj2);
ASSERT_EQ(lobj.retira(), obj2);
}
TEST_F(TesteLista, retiraDoInicioDuplo) {
Objeto obj0(20);
Objeto obj1(10);
Objeto obj2(40);
lobj.adicionaDuplo(obj0);
lobj.adicionaDuplo(obj1);
lobj.adicionaDuplo(obj2);
lobj.retiraDoInicioDuplo();
ASSERT_EQ(lobj.retiraDoInicioDuplo(), obj1);
}
TEST_F(TesteFila, UltimaPosicaoElementoComplexo){
Objeto obj0(10);
Objeto obj1(5);
Objeto obj2(2);
filaobj.inclui(obj0);
filaobj.inclui(obj1);
filaobj.inclui(obj2);
ASSERT_EQ(2, fila.getUltimo());
}
TEST(ObjectTest, test_circular_with_object_weak) {
LifeCycleMock mock;
EXPECT_CALL(mock, constructed()).Times(2);
EXPECT_CALL(mock, destructed()).Times(2);
TestObject::Ptr obj0(TestObject::New(&mock));
TestObject::Ptr obj1(TestObject::New(&mock));
obj0->set_other(obj1);
obj1->set_other(obj0);
}
TEST_F(TesteLista, retiraEspecificoDuplo) {
Objeto obj0(0);
Objeto obj1(1);
Objeto obj2(2);
Objeto obj3(3);
Objeto obj4(4);
lobj.adicionaDuplo(obj0);
lobj.adicionaDuplo(obj1);
lobj.adicionaDuplo(obj2);
lobj.adicionaDuplo(obj3);
lobj.adicionaDuplo(obj4);
ASSERT_EQ(lobj.retiraEspecificoDuplo(obj3), 3);
}
TEST_F(TesteLista, MaiorObjDuplo) {
Objeto obj0(20);
Objeto obj1(10);
ASSERT_TRUE(lobj.maior(obj0, obj1));
}
TEST_F(TesteLista, IgualObjDuplo) {
Objeto obj0(10);
Objeto obj1(10);
ASSERT_TRUE(lobj.igual(obj0, obj1));
}
TEST_F(TesteLista, MenorObj) {
Objeto obj0(10);
Objeto obj1(20);
ASSERT_TRUE(lobj.menor(obj0, obj1));
}
static void test_autostarray(skiatest::Reporter* reporter) {
RefClass obj0(0);
RefClass obj1(1);
REPORTER_ASSERT(reporter, obj0.unique());
REPORTER_ASSERT(reporter, obj1.unique());
{
SkAutoSTArray<2, SkAutoTUnref<RefClass> > tmp;
REPORTER_ASSERT(reporter, 0 == tmp.count());
tmp.reset(0); // test out reset(0) when already at 0
tmp.reset(4); // this should force a new allocation
REPORTER_ASSERT(reporter, 4 == tmp.count());
tmp[0].reset(SkRef(&obj0));
tmp[1].reset(SkRef(&obj1));
REPORTER_ASSERT(reporter, !obj0.unique());
REPORTER_ASSERT(reporter, !obj1.unique());
// test out reset with data in the array (and a new allocation)
tmp.reset(0);
REPORTER_ASSERT(reporter, 0 == tmp.count());
REPORTER_ASSERT(reporter, obj0.unique());
REPORTER_ASSERT(reporter, obj1.unique());
tmp.reset(2); // this should use the preexisting allocation
REPORTER_ASSERT(reporter, 2 == tmp.count());
tmp[0].reset(SkRef(&obj0));
tmp[1].reset(SkRef(&obj1));
}
// test out destructor with data in the array (and using existing allocation)
REPORTER_ASSERT(reporter, obj0.unique());
REPORTER_ASSERT(reporter, obj1.unique());
{
// test out allocating ctor (this should allocate new memory)
SkAutoSTArray<2, SkAutoTUnref<RefClass> > tmp(4);
REPORTER_ASSERT(reporter, 4 == tmp.count());
tmp[0].reset(SkRef(&obj0));
tmp[1].reset(SkRef(&obj1));
REPORTER_ASSERT(reporter, !obj0.unique());
REPORTER_ASSERT(reporter, !obj1.unique());
// Test out resut with data in the array and malloced storage
tmp.reset(0);
REPORTER_ASSERT(reporter, obj0.unique());
REPORTER_ASSERT(reporter, obj1.unique());
tmp.reset(2); // this should use the preexisting storage
tmp[0].reset(SkRef(&obj0));
tmp[1].reset(SkRef(&obj1));
REPORTER_ASSERT(reporter, !obj0.unique());
REPORTER_ASSERT(reporter, !obj1.unique());
tmp.reset(4); // this should force a new malloc
REPORTER_ASSERT(reporter, obj0.unique());
REPORTER_ASSERT(reporter, obj1.unique());
tmp[0].reset(SkRef(&obj0));
tmp[1].reset(SkRef(&obj1));
REPORTER_ASSERT(reporter, !obj0.unique());
REPORTER_ASSERT(reporter, !obj1.unique());
}
REPORTER_ASSERT(reporter, obj0.unique());
REPORTER_ASSERT(reporter, obj1.unique());
}
TEST(ObjectTest, test_object_ptr_validation_as_container_hash_key) {
LifeCycleMock mock;
EXPECT_CALL(mock, constructed()).Times(1);
EXPECT_CALL(mock, destructed()).Times(1);
TestObject::Ptr obj0(TestObject::New(&mock));
TestObject::Ptr obj1(obj0);
TestObject::Ptr obj2(obj1);
TestObject * obj = obj0.get();
{
std::set<TestObject::Ptr> set;
set.insert(obj0);
EXPECT_NE(set.end(), set.find(obj0));
EXPECT_NE(set.end(), set.find(obj1));
EXPECT_NE(set.end(), set.find(obj2));
EXPECT_NE(set.end(), set.find(obj));
}
{
std::unordered_set<TestObject::Ptr> uset;
uset.insert(obj0);
EXPECT_NE(uset.end(), uset.find(obj0));
EXPECT_NE(uset.end(), uset.find(obj1));
EXPECT_NE(uset.end(), uset.find(obj2));
EXPECT_NE(uset.end(), uset.find(obj));
}
{
std::map<TestObject::Ptr, int> map;
map[obj0] = 0;
EXPECT_EQ(0, map[obj0]);
EXPECT_EQ(0, map[obj1]);
EXPECT_EQ(0, map[obj2]);
EXPECT_EQ(0, map[obj]);
map[obj1] = 1;
EXPECT_EQ(1, map[obj0]);
EXPECT_EQ(1, map[obj1]);
EXPECT_EQ(1, map[obj2]);
EXPECT_EQ(1, map[obj]);
map[obj2] = 2;
EXPECT_EQ(2, map[obj0]);
EXPECT_EQ(2, map[obj1]);
EXPECT_EQ(2, map[obj2]);
EXPECT_EQ(2, map[obj]);
map[obj] = 3;
EXPECT_EQ(3, map[obj0]);
EXPECT_EQ(3, map[obj1]);
EXPECT_EQ(3, map[obj2]);
EXPECT_EQ(3, map[obj]);
}
{
std::unordered_map<TestObject::Ptr, int> umap;
umap[obj0] = 0;
EXPECT_EQ(0, umap[obj0]);
EXPECT_EQ(0, umap[obj1]);
EXPECT_EQ(0, umap[obj2]);
EXPECT_EQ(0, umap[obj]);
umap[obj1] = 1;
EXPECT_EQ(1, umap[obj0]);
EXPECT_EQ(1, umap[obj1]);
EXPECT_EQ(1, umap[obj2]);
EXPECT_EQ(1, umap[obj]);
umap[obj2] = 2;
EXPECT_EQ(2, umap[obj0]);
EXPECT_EQ(2, umap[obj1]);
EXPECT_EQ(2, umap[obj2]);
EXPECT_EQ(2, umap[obj]);
umap[obj] = 3;
EXPECT_EQ(3, umap[obj0]);
EXPECT_EQ(3, umap[obj1]);
EXPECT_EQ(3, umap[obj2]);
EXPECT_EQ(3, umap[obj]);
}
}
