packageindex/Package_test.cpp at master · jgoldsch/packageindex · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
#include "Package.h"
#include <memory>
#include <gtest/gtest.h>

using namespace std;

TEST(PackageTest, SourceNode) {
  auto p = make_shared<Package>("testpackage");
  // package with no dependencies is a source in DAG
  ASSERT_TRUE(p->isSource());
}

TEST(PackageTest, SinkNode) {
  auto p = make_shared<Package>("testpackage");
  // a new package is also a sink
  ASSERT_TRUE(p->isSink());
}

TEST(PackageTest, AddDependency) {
  auto p = make_shared<Package>("testpackage");
  Package *pdep = new Package("testdepend");

  int err = p->addDependency(pdep);

  ASSERT_EQ(err, 0);

  // Our Graph:  testpackage->testdepend

  // Cannot be a source with a dependency
  ASSERT_FALSE(p->isSource());
  // Still a sink with no dependents
  ASSERT_TRUE(p->isSink());

  // The dependent object is a source, as it has no dependencies in our graph
  ASSERT_TRUE(pdep->isSource());
  // The dependent object is not a sink, because p depends on it.
  ASSERT_FALSE(pdep->isSink());

  delete pdep;
}

TEST(PackageTest, AddSelfDependency) {
  auto p = make_shared<Package>("testpackage");
  Package *pdep = new Package("testpackage");

  int err = p->addDependency(pdep);

  // insert will fail, because of circular dependency
  ASSERT_EQ(err, -1);
  // package ist still a source, no dependencies
  ASSERT_TRUE(p->isSource());
  // Still a sink with no dependents
  ASSERT_TRUE(p->isSink());

  delete pdep;
}

TEST(PackageTest, AddDependent) {
  auto p = make_shared<Package>("testpackage");
  Package *pdep = new Package("testdependent");

  int err = p->addDependent(pdep);

  // Our Graph:  testdependent->testpackage

  ASSERT_EQ(err, 0);

  // Still a source, no dependencies
  ASSERT_TRUE(p->isSource());
  // Not a sink, since there is a dependent
  ASSERT_FALSE(p->isSink());

  delete pdep;
}

TEST(PackageTest, RemoveDependency) {
  auto p = make_shared<Package>("testpackage");
  Package *pdep = new Package("testdepend");

  int err = p->addDependency(pdep);

  ASSERT_EQ(err, 0);

  // Our Graph:  testpackage->testdepend

  err = p->removeDependency(pdep);
  delete pdep;

  // Our Graph:  testpackage

  ASSERT_EQ(err, 0);

  // package is a source, no dependencies
  ASSERT_TRUE(p->isSource());
  // package is a sink with no dependents
  ASSERT_TRUE(p->isSink());
}


TEST(PackageTest, SearchTest) {
  Package *pA = new Package("A");
  Package *pB = new Package("B");
  Package *pC = new Package("C");
  int err = pA->addDependency(pB);
  ASSERT_EQ(err, 0);
  err = pA->addDependency(pC);
  ASSERT_EQ(err, 0);

  ASSERT_EQ((pA->search("C"))->getName(), "C");
  ASSERT_EQ((pA->search("B"))->getName(), "B");
  ASSERT_EQ((pA->search("A"))->getName(), "A");
  ASSERT_EQ(pA->search("foo"), nullptr);
  delete pA;
  delete pB;
  delete pC;
}

TEST(PackageTest, DeepSearchTest) {
  Package *pA = new Package("A");
  int i,j;
  list<Package *> testobjs;
  for (i = 0; i < 10; ++i) {
    Package *newP = new Package((to_string(i)));
    testobjs.push_back(newP);
    pA->addDependency(newP);
    for (j=100; j < 110; ++j) {
      Package *newnewP = new Package((to_string(j*i+1)));
      testobjs.push_back(newnewP);
      newP->addDependency(newnewP);
    }
  }

  ASSERT_EQ(pA->search(to_string(901))->getName(), to_string(901));
  for (auto p : testobjs) {
    delete p;
  }
  delete pA;
}


int main(int argc, char **argv) {
  testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}