[prev in list] [next in list] [prev in thread] [next in thread] 

List:       kde-commits
Subject:    playground/network/libktelepathy/tests
From:       George Goldberg <grundleborg () googlemail ! com>
Date:       2010-09-22 11:39:26
Message-ID: 20100922113926.70AF3AC88E () svn ! kde ! org
[Download RAW message or body]

SVN commit 1178202 by gberg:

Complete the Entity unit test.

 M  +158 -9    entity-test.cpp  
 M  +0 -1      entity-test.h  


--- trunk/playground/network/libktelepathy/tests/entity-test.cpp #1178201:1178202
@@ -97,37 +97,186 @@
     resource.remove();
 }
 
-void EntityTest::testOperatorsEqualsNotEqual()
+void EntityTest::testqHash()
 {
-    // Try equating two invalid Entities.
+    // Use a QSet to test the qHash implementation
+    QSet<EntityPtr> entities;
 
-    // Try equating two different valid entities
+    // Add a valid Entity Ptr
+    Nepomuk::Resource resource1(QUrl::fromEncoded("nepomuk:/entity-test-qHash-1"));
+    resource1.addType(Nepomuk::Vocabulary::NCO::PersonContact());
 
-    // Try equating two same valid entities
+    QVERIFY(resource1.exists());
+    QVERIFY(resource1.hasType(Nepomuk::Vocabulary::NCO::PersonContact()));
 
-    // Try equating two same valid, but removed from nepomuk entities
+    EntityPtr entity1 = TestBackdoors::entityConstruct(resource1);
 
-    // Try equating two different valid, but removed from nepomuk entities.
-}
+    entities.insert(entity1);
 
-void EntityTest::testqHash()
-{
+    QCOMPARE(entities.size(), 1);
+    QVERIFY(entities.contains(entity1));
 
+    // Add another valid Entity Ptr
+    Nepomuk::Resource resource2(QUrl::fromEncoded("nepomuk:/entity-test-qHash-2"));
+    resource2.addType(Nepomuk::Vocabulary::NCO::PersonContact());
+
+    QVERIFY(resource2.exists());
+    QVERIFY(resource2.hasType(Nepomuk::Vocabulary::NCO::PersonContact()));
+
+    EntityPtr entity2 = TestBackdoors::entityConstruct(resource2);
+
+    entities.insert(entity2);
+
+    QCOMPARE(entities.size(), 2);
+    QVERIFY(entities.contains(entity1));
+    QVERIFY(entities.contains(entity2));
+
+    // Add the same EntityPtr again
+    entities.insert(entity2);
+
+    QCOMPARE(entities.size(), 2);
+    QVERIFY(entities.contains(entity1));
+    QVERIFY(entities.contains(entity2));
+
+    // Add a different EntityPtr to the same Entity again.
+    EntityPtr entity3 = TestBackdoors::entityConstruct(resource2);
+
+    entities.insert(entity3);
+
+    QCOMPARE(entities.size(), 3);
+    QVERIFY(entities.contains(entity1));
+    QVERIFY(entities.contains(entity2));
+    QVERIFY(entities.contains(entity3));
+
+    // Add an invalid EntityPtr
+    EntityPtr entity4 = TestBackdoors::entityConstruct();
+
+    entities.insert(entity4);
+
+    QCOMPARE(entities.size(), 4);
+    QVERIFY(entities.contains(entity1));
+    QVERIFY(entities.contains(entity2));
+    QVERIFY(entities.contains(entity3));
+    QVERIFY(entities.contains(entity4));
+
+    // Add the same invalid EntityPtr again
+    entities.insert(entity4);
+
+    QCOMPARE(entities.size(), 4);
+    QVERIFY(entities.contains(entity1));
+    QVERIFY(entities.contains(entity2));
+    QVERIFY(entities.contains(entity3));
+    QVERIFY(entities.contains(entity4));
+
+    // Add another invalid EntityPtr
+    EntityPtr entity5 = TestBackdoors::entityConstruct();
+
+    entities.insert(entity5);
+
+    QCOMPARE(entities.size(), 5);
+    QVERIFY(entities.contains(entity1));
+    QVERIFY(entities.contains(entity2));
+    QVERIFY(entities.contains(entity3));
+    QVERIFY(entities.contains(entity4));
+    QVERIFY(entities.contains(entity5));
+
+    // Cleanup Nepomuk data
+    resource1.remove();
+    resource2.remove();
 }
 
 void EntityTest::testResource()
 {
+    // Create a valid Entity Ptr
+    Nepomuk::Resource resource(QUrl::fromEncoded("nepomuk:/entity-test-resource-1"));
+    resource.addType(Nepomuk::Vocabulary::NCO::PersonContact());
+    QVERIFY(resource.exists());
+    QVERIFY(resource.hasType(Nepomuk::Vocabulary::NCO::PersonContact()));
 
+    EntityPtr entity1 = TestBackdoors::entityConstruct(resource);
+
+    // The resource should be invalid until we setValid the entity.
+    QCOMPARE(entity1->resource(), Nepomuk::Resource());
+
+    // But valid, once setValid is true
+    TestBackdoors::entitySetValid(entity1, true);
+    QCOMPARE(entity1->resource(), resource);
+
+    // Remove the resource from Nepomuk
+    resource.remove();
+
+    // Check the resource() method is now invalid
+    QCOMPARE(entity1->resource(), Nepomuk::Resource());
+
+    // An invalid entity should return an invalid resource
+    EntityPtr entity2 = TestBackdoors::entityConstruct();
+    QCOMPARE(entity2->resource(), Nepomuk::Resource());
+
+    // Cleanup Nepomuk data
+    // No cleanup needed here
 }
 
 void EntityTest::testResourceUri()
 {
+    // Create an invalid Entity Ptr
+    EntityPtr entity1 = TestBackdoors::entityConstruct();
 
+    // Check the resourceUri() is invalid
+    QCOMPARE(entity1->resourceUri(), QUrl());
+
+    // Create a valid Entity Ptr
+    QUrl resourceUri = QUrl::fromEncoded("nepomuk:/entity-test-resource-uri-1");
+    Nepomuk::Resource resource(resourceUri);
+    resource.addType(Nepomuk::Vocabulary::NCO::PersonContact());
+    QVERIFY(resource.exists());
+    QVERIFY(resource.hasType(Nepomuk::Vocabulary::NCO::PersonContact()));
+
+    EntityPtr entity2 = TestBackdoors::entityConstruct(resource);
+
+    // The resourceUri should be valid immediately
+    QCOMPARE(entity2->resourceUri(), resourceUri);
+
+    // Remove the resource from Nepomuk
+    resource.remove();
+
+    // Check the resource URI is still valid
+    QCOMPARE(entity2->resourceUri(), resourceUri);
+
+    // Cleanup Nepomuk data
+    // No cleanup needed here
 }
 
 void EntityTest::testValidSetValid()
 {
+    // Create an entity from a valid Nepomuk Resource
+    Nepomuk::Resource resource(QUrl::fromEncoded("nepomuk:/entity-test-valid-set-valid-1"));
+    resource.addType(Nepomuk::Vocabulary::NCO::PersonContact());
+    QVERIFY(resource.exists());
+    QVERIFY(resource.hasType(Nepomuk::Vocabulary::NCO::PersonContact()));
 
+    EntityPtr entity1 = TestBackdoors::entityConstruct(resource);
+
+    // Check that it is invalid
+    QVERIFY(!entity1->isValid());
+
+    // Mark it as valid
+    TestBackdoors::entitySetValid(entity1, true);
+    QVERIFY(entity1->isValid());
+
+    // Remove the Nepomuk Resource and check it remains valid
+    resource.remove();
+    QVERIFY(entity1->isValid());
+
+    // Manually set it as invalid, as a subclass would
+    TestBackdoors::entitySetValid(entity1, false);
+    QVERIFY(!entity1->isValid());
+
+    // Check that a newly constructed invalid entity is valid() == false
+    EntityPtr entity2 = TestBackdoors::entityConstruct();
+    QVERIFY(!entity2->isValid());
+
+    // Cleanup Nepomuk data
+    // Nothing to cleanup here
 }
 
 
--- trunk/playground/network/libktelepathy/tests/entity-test.h #1178201:1178202
@@ -41,7 +41,6 @@
     void testConstructorDestructor();
     void testResource();
     void testResourceUri();
-    void testOperatorsEqualsNotEqual();
     void testValidSetValid();
     void testqHash();
 
[prev in list] [next in list] [prev in thread] [next in thread]