← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/soprano/gutsy

« back to all changes in this revision

Viewing changes to test/StatementIteratorTest.cpp

  • Committer: Bazaar Package Importer
  • Author(s): Jonathan Riddell
  • Date: 2007-10-12 14:43:48 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20071012144348-yajzi51v4k23ahxf
Tags: 1.95.0~beta2-1ubuntu1
* Sync with Debian
* Add versioned build-dep on raptor

Show diffs side-by-side

added added

removed removed

Lines of Context:
test/StatementIteratorTest.cpp
29
29
 
30
30
void StatementIteratorTest::cleanup()
31
31
{
32
 
  m_statements.clear();
33
 
  QVERIFY( m_model->removeAll() == ERROR_NONE );
 
32
    delete m_model;
 
33
    m_model = 0;
34
34
}
35
35
 
36
36
void StatementIteratorTest::init()
37
37
{
38
 
  Node resource_1( QUrl("uri:list:resource1") );
39
 
  Node resource_2( QUrl("uri:list:resource2") );
40
 
  Node resource_3( QUrl("uri:list:resource3") );
41
 
 
42
 
  for (int i=0; i<50; i++)
43
 
  {
44
 
    QString property = "predicate" + QString::number(i);
45
 
    QString literal = "Literal value" + QString::number(i);
46
 
 
47
 
    Node predicate( QUrl( "soprano#" + property ) );
48
 
    Node object = LiteralValue( literal );
49
 
 
50
 
    Statement st(resource_1, predicate, object);
51
 
    m_statements.append( st );
52
 
  }
53
 
 
54
 
  for (int i=0; i<50; i++)
55
 
  {
56
 
    QString property = "predicate" + QString::number(i + 50);
57
 
    QString literal = "Literal value" + QString::number(i + 50);
58
 
 
59
 
    Node predicate( QUrl( "soprano#" + property ) );
60
 
    Node object = LiteralValue( literal );
61
 
 
62
 
    Statement st(resource_2, predicate, object);
63
 
    m_statements.append( st );
64
 
  }
65
 
 
66
 
  for (int i=0; i<20; i++)
67
 
  {
68
 
    QString property = "predicate" + QString::number(i + 100);
69
 
    QString literal = "Literal value" + QString::number(i + 100);
70
 
 
71
 
    Node predicate( QUrl( "soprano#" + property ) );
72
 
    Node object = LiteralValue( literal );
73
 
 
74
 
    Statement st(resource_3, predicate, object);
75
 
    m_statements.append( st );
76
 
  }
77
 
 
78
 
  m_model->add( m_statements );
 
38
    m_model = createModel();
 
39
    QVERIFY( m_model != 0 );
 
40
 
 
41
    m_model->addStatements( m_statements );
 
42
}
 
43
 
 
44
void StatementIteratorTest::initTestCase()
 
45
{
 
46
    Node resource_1( QUrl("uri:list:resource1") );
 
47
    Node resource_2( QUrl("uri:list:resource2") );
 
48
    Node resource_3( QUrl("uri:list:resource3") );
 
49
 
 
50
    for (int i=0; i<50; i++)
 
51
    {
 
52
        QString property = "predicate" + QString::number(i);
 
53
        QString literal = "Literal value" + QString::number(i);
 
54
 
 
55
        Node predicate( QUrl( "soprano#" + property ) );
 
56
        Node object = LiteralValue( literal );
 
57
 
 
58
        Statement st(resource_1, predicate, object);
 
59
        m_statements.append( st );
 
60
    }
 
61
 
 
62
    for (int i=0; i<50; i++)
 
63
    {
 
64
        QString property = "predicate" + QString::number(i + 50);
 
65
        QString literal = "Literal value" + QString::number(i + 50);
 
66
 
 
67
        Node predicate( QUrl( "soprano#" + property ) );
 
68
        Node object = LiteralValue( literal );
 
69
 
 
70
        Statement st(resource_2, predicate, object);
 
71
        m_statements.append( st );
 
72
    }
 
73
 
 
74
    for (int i=0; i<20; i++)
 
75
    {
 
76
        QString property = "predicate" + QString::number(i + 100);
 
77
        QString literal = "Literal value" + QString::number(i + 100);
 
78
 
 
79
        Node predicate( QUrl( "soprano#" + property ) );
 
80
        Node object = LiteralValue( literal );
 
81
 
 
82
        Statement st(resource_3, predicate, object);
 
83
        m_statements.append( st );
 
84
    }
79
85
}
80
86
 
81
87
void StatementIteratorTest::testIterator()
82
88
{
83
 
  Node resource_1( QUrl("uri:list:resource1") );
84
 
  Node resource_2( QUrl("uri:list:resource2") );
85
 
  Node resource_3( QUrl("uri:list:resource3") );
86
 
 
87
 
  StatementIterator sti = m_model->listStatements();
88
 
 
89
 
  int cnt = 0;
90
 
  while ( sti.hasNext() )
91
 
  {
92
 
    ++cnt;
93
 
    sti.next();
94
 
  }
95
 
 
96
 
  QVERIFY( cnt == m_statements.size() );
97
 
 
98
 
  /* Resource 1 */
99
 
 
100
 
  StatementIterator sti2 = m_model->listStatements( resource_1, Node(), Node() );
101
 
 
102
 
  cnt = 0;
103
 
  while ( sti2.hasNext() )
104
 
  {
105
 
    ++cnt;
106
 
    sti2.next();
107
 
  }
108
 
 
109
 
  QVERIFY( cnt == 50 );
 
89
    Node resource_1( QUrl("uri:list:resource1") );
 
90
    Node resource_2( QUrl("uri:list:resource2") );
 
91
    Node resource_3( QUrl("uri:list:resource3") );
 
92
 
 
93
    StatementIterator sti = m_model->listStatements();
 
94
 
 
95
    int cnt = 0;
 
96
    while ( sti.next() ) {
 
97
        ++cnt;
 
98
    }
 
99
 
 
100
    QVERIFY( cnt == m_statements.size() );
 
101
 
 
102
    /* Resource 1 */
 
103
 
 
104
    StatementIterator sti2 = m_model->listStatements( Statement( resource_1, Node(), Node() ) );
 
105
 
 
106
    cnt = 0;
 
107
    while ( sti2.next() ) {
 
108
        ++cnt;
 
109
    }
 
110
 
 
111
    QVERIFY( cnt == 50 );
110
112
}
111
113
 
112
114
void StatementIteratorTest::testSharedStuffs()
113
115
{
114
 
  StatementIterator iter1 = m_model->listStatements();
115
 
 
116
 
  int cnt = 0;
117
 
  if ( iter1.hasNext() )
118
 
  {
119
 
    ++cnt;
120
 
    iter1.next();
121
 
  }
122
 
 
123
 
  StatementIterator iter2 = iter1;
124
 
  while ( iter2.hasNext() )
125
 
  {
126
 
      ++cnt;
127
 
      iter2.next();
128
 
  }
129
 
 
130
 
  QVERIFY( cnt == m_statements.size() );
 
116
    StatementIterator iter1 = m_model->listStatements();
 
117
 
 
118
    int cnt = 0;
 
119
    if ( iter1.next() ) {
 
120
        ++cnt;
 
121
    }
 
122
 
 
123
    StatementIterator iter2 = iter1;
 
124
    while ( iter2.next() ) {
 
125
        ++cnt;
 
126
    }
 
127
 
 
128
    QCOMPARE( cnt, m_statements.size() );
 
129
}
 
130
 
 
131
 
 
132
void StatementIteratorTest::testConsistency()
 
133
{
 
134
    StatementIterator it = m_model->listStatements();
 
135
 
 
136
    while ( it.next() ) {
 
137
        QCOMPARE( *it, it.current() );
 
138
    }
131
139
}
132
140
 
133
141
#include "StatementIteratorTest.moc"