This project has retired. For details please refer to its Attic page.
IdAndValueArrayEdgesTest xref
View Javadoc

1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *     http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing, software
13   * distributed under the License is distributed on an "AS IS" BASIS,
14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15   * See the License for the specific language governing permissions and
16   * limitations under the License.
17   */
18  package org.apache.giraph.edge;
19  
20  import com.google.common.collect.Lists;
21  import org.apache.giraph.conf.GiraphConfiguration;
22  import org.apache.giraph.conf.GiraphConstants;
23  import org.apache.giraph.conf.ImmutableClassesGiraphConfiguration;
24  import org.apache.hadoop.io.DoubleWritable;
25  import org.apache.hadoop.io.LongWritable;
26  import org.apache.hadoop.io.Writable;
27  import org.junit.Assert;
28  import org.junit.Test;
29  
30  import java.io.ByteArrayInputStream;
31  import java.io.ByteArrayOutputStream;
32  import java.io.DataInputStream;
33  import java.io.DataOutputStream;
34  import java.io.IOException;
35  import java.util.ArrayList;
36  import java.util.HashSet;
37  import java.util.Iterator;
38  import java.util.List;
39  import java.util.Set;
40  
41  import static org.junit.Assert.assertEquals;
42  import static org.junit.Assert.assertTrue;
43  
44  
45  public class IdAndValueArrayEdgesTest {
46    private static Edge<LongWritable, DoubleWritable> createEdge(long id) {
47      return EdgeFactory.create(new LongWritable(id), new DoubleWritable((double) id));
48    }
49  
50    private static void assertEdges(IdAndValueArrayEdges edges, long... expected) {
51      int index = 0;
52      for (Edge<LongWritable, DoubleWritable> edge :
53        (Iterable<Edge<LongWritable, DoubleWritable>>) edges) {
54        Assert.assertEquals(expected[index], edge.getTargetVertexId().get());
55        Assert.assertEquals((double) expected[index], edge.getValue().get(), 0.00001);
56        index++;
57      }
58      Assert.assertEquals(expected.length, index);
59    }
60  
61    private IdAndValueArrayEdges getEdges() {
62      GiraphConfiguration gc = new GiraphConfiguration();
63      GiraphConstants.VERTEX_ID_CLASS.set(gc, LongWritable.class);
64      GiraphConstants.EDGE_VALUE_CLASS.set(gc, DoubleWritable.class);
65      ImmutableClassesGiraphConfiguration<LongWritable, Writable, DoubleWritable> conf =
66          new ImmutableClassesGiraphConfiguration<LongWritable, Writable, DoubleWritable>(gc);
67      IdAndValueArrayEdges ret = new IdAndValueArrayEdges();
68      ret.setConf(
69        new ImmutableClassesGiraphConfiguration<LongWritable, Writable, DoubleWritable>(conf));
70      return ret;
71    }
72  
73    @Test
74    public void testEdges() {
75      IdAndValueArrayEdges edges = getEdges();
76  
77      List<Edge<LongWritable, DoubleWritable>> initialEdges = Lists.newArrayList(
78          createEdge(1), createEdge(2), createEdge(4));
79  
80      edges.initialize(initialEdges);
81      assertEdges(edges, 1, 2, 4);
82  
83      edges.add(EdgeFactory.createReusable(new LongWritable(3), new DoubleWritable(3.0)));
84      assertEdges(edges, 1, 2, 4, 3); // order matters, it's an array
85  
86      edges.remove(new LongWritable(2));
87      assertEdges(edges, 1, 3, 4);
88    }
89  
90    @Test
91    public void testInitialize() {
92      IdAndValueArrayEdges edges = getEdges();
93  
94      List<Edge<LongWritable, DoubleWritable>> initialEdges = Lists.newArrayList(
95        createEdge(1), createEdge(2), createEdge(4));
96  
97      edges.initialize(initialEdges);
98      assertEdges(edges, 1, 2, 4);
99  
100     edges.add(EdgeFactory.createReusable(new LongWritable(3), new DoubleWritable(3.0)));
101     assertEdges(edges, 1, 2, 4, 3); // order matters, it's an array
102 
103     edges.initialize();
104     assertEquals(0, edges.size());
105   }
106 
107   @Test
108   public void testMutateEdges() {
109     IdAndValueArrayEdges edges = getEdges();
110 
111     edges.initialize();
112 
113     // Add 10 edges with id i, for i = 0..9
114     for (int i = 0; i < 10; ++i) {
115       edges.add(createEdge(i));
116     }
117 
118     // Use the mutable iterator to remove edges with even id
119     Iterator<MutableEdge<LongWritable, DoubleWritable>> edgeIt =
120         edges.mutableIterator();
121     while (edgeIt.hasNext()) {
122       if (edgeIt.next().getTargetVertexId().get() % 2 == 0) {
123         edgeIt.remove();
124       }
125     }
126 
127     // We should now have 5 edges
128     assertEquals(5, edges.size());
129     // The edge ids should be all odd
130     for (Edge<LongWritable, DoubleWritable> edge :
131       (Iterable<Edge<LongWritable, DoubleWritable>>) edges) {
132       assertEquals(1, edge.getTargetVertexId().get() % 2);
133     }
134   }
135 
136   @Test
137   public void testSerialization() throws IOException {
138     IdAndValueArrayEdges edges = getEdges();
139 
140     edges.initialize();
141 
142     // Add 10 edges with id i, for i = 0..9
143     for (int i = 0; i < 10; ++i) {
144       edges.add(createEdge(i));
145     }
146 
147     // Use the mutable iterator to remove edges with even id
148     Iterator<MutableEdge<LongWritable, DoubleWritable>> edgeIt =
149         edges.mutableIterator();
150     while (edgeIt.hasNext()) {
151       if (edgeIt.next().getTargetVertexId().get() % 2 == 0) {
152         edgeIt.remove();
153       }
154     }
155 
156     // We should now have 5 edges
157     assertEdges(edges, 9, 1, 7, 3, 5); // id order matter because of the implementation
158 
159     ByteArrayOutputStream arrayStream = new ByteArrayOutputStream();
160     DataOutputStream tempBuffer = new DataOutputStream(arrayStream);
161 
162     edges.write(tempBuffer);
163     tempBuffer.close();
164 
165     byte[] binary = arrayStream.toByteArray();
166 
167     assertTrue("Serialized version should not be empty ", binary.length > 0);
168 
169     edges = getEdges();
170     edges.readFields(new DataInputStream(new ByteArrayInputStream(binary)));
171 
172     assertEquals(5, edges.size());
173 
174     long[] ids = new long[]{9, 1, 7, 3, 5};
175     int index = 0;
176 
177     for (Edge<LongWritable, DoubleWritable> edge :
178       (Iterable<Edge<LongWritable, DoubleWritable>>) edges) {
179       assertEquals(ids[index], edge.getTargetVertexId().get());
180       assertEquals((double) ids[index], edge.getValue().get(), 0.00001);
181       index++;
182     }
183     assertEquals(ids.length, index);
184   }
185 
186   @Test
187   public void testParallelEdges() {
188     IdAndValueArrayEdges edges = getEdges();
189 
190     List<Edge<LongWritable, DoubleWritable>> initialEdges = Lists.newArrayList(
191         createEdge(2), createEdge(2), createEdge(2));
192 
193     edges.initialize(initialEdges);
194     assertEquals(3, edges.size());
195 
196     edges.remove(new LongWritable(2));
197     assertEquals(0, edges.size());
198 
199     edges.add(EdgeFactory.create(new LongWritable(2), new DoubleWritable(2.0)));
200     assertEquals(1, edges.size());
201 
202     assertEquals(1, edges.size());
203   }
204 
205   @Test
206   public void testEdgeValues() {
207     IdAndValueArrayEdges edges = getEdges();
208     Set<Long> testValues = new HashSet<Long>();
209     testValues.add(0L);
210     testValues.add((long) Integer.MAX_VALUE);
211     testValues.add(Long.MAX_VALUE);
212 
213     List<Edge<LongWritable, DoubleWritable>> initialEdges =
214       new ArrayList<Edge<LongWritable, DoubleWritable>>();
215     for(Long id : testValues) {
216       initialEdges.add(createEdge(id));
217     }
218 
219     edges.initialize(initialEdges);
220 
221     Iterator<MutableEdge<LongWritable, DoubleWritable>> edgeIt =
222         edges.mutableIterator();
223     while (edgeIt.hasNext()) {
224       long value = edgeIt.next().getTargetVertexId().get();
225       assertTrue("Unknown edge found " + value, testValues.remove(value));
226     }
227   }
228 
229   @Test
230   public void testAddedSmallerValues() {
231     IdAndValueArrayEdges edges = getEdges();
232 
233     List<Edge<LongWritable, DoubleWritable>> initialEdges = Lists.newArrayList(
234         createEdge(100));
235 
236     edges.initialize(initialEdges);
237 
238     for (int i=0; i<16; i++) {
239       edges.add(createEdge(i));
240     }
241 
242     assertEquals(17, edges.size());
243   }
244 }