@Override public Coder<CovarianceAccumulator> getAccumulatorCoder( CoderRegistry registry, Coder<Row> inputCoder) { return SerializableCoder.of(CovarianceAccumulator.class); }
@Override public Coder<KinesisReaderCheckpoint> getCheckpointMarkCoder() { return SerializableCoder.of(KinesisReaderCheckpoint.class); }
@Override public Coder<ObjectId> getOutputCoder() { return SerializableCoder.of(ObjectId.class); }
@Override public Coder<VarianceAccumulator> getAccumulatorCoder( CoderRegistry registry, Coder<T> inputCoder) { return SerializableCoder.of(VarianceAccumulator.class); }
@Override public Coder<Accum> getAccumulatorCoder(CoderRegistry registry, Coder<String> inputCoder) throws CannotProvideCoderException { return SerializableCoder.of(Accum.class); }
@Test public <T extends Serializable> void testSerializableCoderIsSerializableWithGenericTypeToken() throws Exception { SerializableCoder<T> coder = SerializableCoder.of(new TypeDescriptor<T>() {}); CoderProperties.coderSerializable(coder); }
@Test public void coderChecksForEquals() throws Exception { SerializableCoder.of(ProperEquals.class); expectedLogs.verifyNotLogged("Can't verify serialized elements of type"); }
@Test public void testListWithNullsAndSerializableCoder() throws Exception { List<Integer> list = Arrays.asList(1, 2, 3, null, 4); Coder<List<Integer>> coder = ListCoder.of(SerializableCoder.of(Integer.class)); CoderProperties.coderDecodeEncodeEqual(coder, list); }
@Test public void testEncodedTypeDescriptor() throws Exception { assertThat( SerializableCoder.of(MyRecord.class).getEncodedTypeDescriptor(), Matchers.equalTo(TypeDescriptor.of(MyRecord.class))); }
@Test public void testNullEquals() { SerializableCoder<MyRecord> coder = SerializableCoder.of(MyRecord.class); Assert.assertFalse(coder.equals(null)); }
@Test public void testSerializableCoder() throws Exception { IterableCoder<MyRecord> coder = IterableCoder.of(SerializableCoder.of(MyRecord.class)); List<MyRecord> records = new ArrayList<>(); for (String l : LINES) { records.add(new MyRecord(l)); } byte[] encoded = CoderUtils.encodeToByteArray(coder, records); Iterable<MyRecord> decoded = CoderUtils.decodeFromByteArray(coder, encoded); assertEquals(records, decoded); }
@Test @SuppressWarnings("rawtypes") public void testSerializableTypeVariableDefaultCoder() throws Exception { CoderRegistry registry = CoderRegistry.createDefault(); TypeDescriptor type = TypeDescriptor.of(TestSerializableGenericClass.class.getTypeParameters()[0]); assertEquals(SerializableCoder.of(type), registry.getCoder(type)); }
@Test public void testDefaultCoderAnnotationGeneric() throws Exception { CoderRegistry registry = CoderRegistry.createDefault(); assertEquals( registry.getCoder(new TypeDescriptor<MySerializableGeneric<String>>() {}), SerializableCoder.of(MySerializableGeneric.class)); }
@Test public void testNullEncoding() throws Exception { Coder<String> coder = SerializableCoder.of(String.class); byte[] encodedBytes = CoderUtils.encodeToByteArray(coder, null); assertNull(CoderUtils.decodeFromByteArray(coder, encodedBytes)); }
@Test public void testDefaultCoderAnnotationGenericRawtype() throws Exception { CoderRegistry registry = CoderRegistry.createDefault(); assertEquals( registry.getCoder(MySerializableGeneric.class), SerializableCoder.of(MySerializableGeneric.class)); }
@Test public void testDefaultCoderInCollection() throws Exception { CoderRegistry registry = CoderRegistry.createDefault(); registry.registerCoderProvider(new DefaultCoderProvider()); Coder<List<AvroRecord>> avroRecordCoder = registry.getCoder(new TypeDescriptor<List<AvroRecord>>() {}); assertThat(avroRecordCoder, instanceOf(ListCoder.class)); assertThat(((ListCoder) avroRecordCoder).getElemCoder(), instanceOf(AvroCoder.class)); assertThat( registry.getCoder(new TypeDescriptor<List<SerializableRecord>>() {}), Matchers.equalTo(ListCoder.of(SerializableCoder.of(SerializableRecord.class)))); }
@Test public void testSerializableCoderConstruction() throws Exception { SerializableCoder<MyRecord> coder = SerializableCoder.of(MyRecord.class); assertEquals(coder.getRecordType(), MyRecord.class); CoderProperties.coderSerializable(coder); SerializableCoder<?> decoded = SerializableUtils.clone(coder); assertThat(decoded.getRecordType(), Matchers.<Object>equalTo(MyRecord.class)); }
@Test @Category(ValidatesRunner.class) public void testCreateWithNullsAndValues() throws Exception { PCollection<String> output = p.apply( Create.of(null, "test1", null, "test2", null) .withCoder(SerializableCoder.of(String.class))); PAssert.that(output).containsInAnyOrder(null, "test1", null, "test2", null); p.run(); }
@Test public void testCoderPrecedence() throws Exception { CoderRegistry registry = CoderRegistry.createDefault(); // DefaultCoder precedes CoderProviderRegistrar assertEquals(AvroCoder.of(MyValueA.class), registry.getCoder(MyValueA.class)); // CoderProviderRegistrar precedes SerializableCoder assertEquals(MyValueBCoder.INSTANCE, registry.getCoder(MyValueB.class)); // fallbacks to SerializableCoder at last assertEquals(SerializableCoder.of(MyValueC.class), registry.getCoder(MyValueC.class)); }
@Parameters(name = "{index}: {0}") public static Iterable<Coder<?>> data() { return ImmutableList.<Coder<?>>builder() .addAll(KNOWN_CODERS) .add( StringUtf8Coder.of(), SerializableCoder.of(Record.class), new RecordCoder(), KvCoder.of(new RecordCoder(), AvroCoder.of(Record.class))) .build(); }