From 2213e54bb58852c37eeda8eb572354076508ff2f Mon Sep 17 00:00:00 2001 From: aibrahiim Date: Sat, 24 Oct 2026 00:23:04 +0300 Subject: [PATCH] rename TestRecord --- .../direct/CloningBundleFactoryTest.java | 46 +++++++-------- .../dataflow/util/CloudObjectsTest.java | 15 ++--- .../beam/sdk/transforms/CreateTest.java | 59 ++++++++++--------- 3 files changed, 62 insertions(+), 58 deletions(-) diff --git a/runners/direct-java/src/test/java/org/apache/beam/runners/direct/CloningBundleFactoryTest.java b/runners/direct-java/src/test/java/org/apache/beam/runners/direct/CloningBundleFactoryTest.java index 6d98e3c32acc..20c2757d5e92 100644 --- a/runners/direct-java/src/test/java/org/apache/beam/runners/direct/CloningBundleFactoryTest.java +++ b/runners/direct-java/src/test/java/org/apache/beam/runners/direct/CloningBundleFactoryTest.java @@ -62,10 +62,10 @@ public class CloningBundleFactoryTest { @Test public void rootBundleSucceedsIgnoresCoder() { - WindowedValue one = WindowedValues.valueInGlobalWindow(new Record()); - WindowedValue two = WindowedValues.valueInGlobalWindow(new Record()); - CommittedBundle root = - factory.createRootBundle().add(one).add(two).commit(Instant.now()); + WindowedValue one = WindowedValues.valueInGlobalWindow(new TestRecord()); + WindowedValue two = WindowedValues.valueInGlobalWindow(new TestRecord()); + CommittedBundle root = + factory.createRootBundle().add(one).add(two).commit(Instant.now()); assertThat(root.getElements(), containsInAnyOrder(one, two)); } @@ -122,71 +122,71 @@ public void keyedBundleWorkingCoderSucceedsClonesOutput() { @Test public void bundleEncodeFailsAddFails() { - PCollection pc = p.apply(Create.empty(new RecordNoEncodeCoder())); - UncommittedBundle bundle = factory.createBundle(pc); + PCollection pc = p.apply(Create.empty(new TestRecordNoEncodeCoder())); + UncommittedBundle bundle = factory.createBundle(pc); thrown.expect(UserCodeException.class); thrown.expectCause(isA(CoderException.class)); thrown.expectMessage("Encode not allowed"); - bundle.add(WindowedValues.valueInGlobalWindow(new Record())); + bundle.add(WindowedValues.valueInGlobalWindow(new TestRecord())); } @Test public void bundleDecodeFailsAddFails() { - PCollection pc = p.apply(Create.empty(new RecordNoDecodeCoder())); - UncommittedBundle bundle = factory.createBundle(pc); + PCollection pc = p.apply(Create.empty(new TestRecordNoDecodeCoder())); + UncommittedBundle bundle = factory.createBundle(pc); thrown.expect(UserCodeException.class); thrown.expectCause(isA(CoderException.class)); thrown.expectMessage("Decode not allowed"); - bundle.add(WindowedValues.valueInGlobalWindow(new Record())); + bundle.add(WindowedValues.valueInGlobalWindow(new TestRecord())); } @Test public void keyedBundleEncodeFailsAddFails() { - PCollection pc = p.apply(Create.empty(new RecordNoEncodeCoder())); - UncommittedBundle bundle = + PCollection pc = p.apply(Create.empty(new TestRecordNoEncodeCoder())); + UncommittedBundle bundle = factory.createKeyedBundle(StructuralKey.of("foo", StringUtf8Coder.of()), pc); thrown.expect(UserCodeException.class); thrown.expectCause(isA(CoderException.class)); thrown.expectMessage("Encode not allowed"); - bundle.add(WindowedValues.valueInGlobalWindow(new Record())); + bundle.add(WindowedValues.valueInGlobalWindow(new TestRecord())); } @Test public void keyedBundleDecodeFailsAddFails() { - PCollection pc = p.apply(Create.empty(new RecordNoDecodeCoder())); - UncommittedBundle bundle = + PCollection pc = p.apply(Create.empty(new TestRecordNoDecodeCoder())); + UncommittedBundle bundle = factory.createKeyedBundle(StructuralKey.of("foo", StringUtf8Coder.of()), pc); thrown.expect(UserCodeException.class); thrown.expectCause(isA(CoderException.class)); thrown.expectMessage("Decode not allowed"); - bundle.add(WindowedValues.valueInGlobalWindow(new Record())); + bundle.add(WindowedValues.valueInGlobalWindow(new TestRecord())); } - static class Record {} + static class TestRecord {} - static class RecordNoEncodeCoder extends AtomicCoder { + static class TestRecordNoEncodeCoder extends AtomicCoder { @Override - public void encode(Record value, OutputStream outStream) throws IOException { + public void encode(TestRecord value, OutputStream outStream) throws IOException { throw new CoderException("Encode not allowed"); } @Override - public Record decode(InputStream inStream) throws IOException { + public TestRecord decode(InputStream inStream) throws IOException { return null; } } - static class RecordNoDecodeCoder extends AtomicCoder { + static class TestRecordNoDecodeCoder extends AtomicCoder { @Override - public void encode(Record value, OutputStream outStream) throws IOException {} + public void encode(TestRecord value, OutputStream outStream) throws IOException {} @Override - public Record decode(InputStream inStream) throws IOException { + public TestRecord decode(InputStream inStream) throws IOException { throw new CoderException("Decode not allowed"); } } diff --git a/runners/google-cloud-dataflow-java/src/test/java/org/apache/beam/runners/dataflow/util/CloudObjectsTest.java b/runners/google-cloud-dataflow-java/src/test/java/org/apache/beam/runners/dataflow/util/CloudObjectsTest.java index fabacd4b877e..f328602e1707 100644 --- a/runners/google-cloud-dataflow-java/src/test/java/org/apache/beam/runners/dataflow/util/CloudObjectsTest.java +++ b/runners/google-cloud-dataflow-java/src/test/java/org/apache/beam/runners/dataflow/util/CloudObjectsTest.java @@ -159,10 +159,10 @@ public static Iterable> data() { IntervalWindow.getCoder())) .add(ByteArrayCoder.of()) .add(VarLongCoder.of()) - .add(SerializableCoder.of(Record.class)) + .add(SerializableCoder.of(TestRecord.class)) .add(AvroCoder.generic(avroSchema)) .add(AvroCoder.specific(AvroGeneratedUser.class)) - .add(AvroCoder.reflect(Record.class)) + .add(AvroCoder.reflect(TestRecord.class)) .add(CollectionCoder.of(VarLongCoder.of())) .add(ListCoder.of(VarLongCoder.of())) .add(SetCoder.of(VarLongCoder.of())) @@ -254,7 +254,7 @@ private static void checkPipelineProtoCoderIds( } } - private static class Record implements Serializable {} + private static class TestRecord implements Serializable {} private static org.apache.avro.Schema avroSchema = new org.apache.avro.Schema.Parser() @@ -286,13 +286,14 @@ public int hashCode() { } /** A non-custom coder with no registered translator. */ - private static class ArbitraryCoder extends StructuredCoder { + private static class ArbitraryCoder extends StructuredCoder { @Override - public void encode(Record value, OutputStream outStream) throws CoderException, IOException {} + public void encode(TestRecord value, OutputStream outStream) + throws CoderException, IOException {} @Override - public Record decode(InputStream inStream) throws CoderException, IOException { - return new Record(); + public TestRecord decode(InputStream inStream) throws CoderException, IOException { + return new TestRecord(); } @Override diff --git a/sdks/java/core/src/test/java/org/apache/beam/sdk/transforms/CreateTest.java b/sdks/java/core/src/test/java/org/apache/beam/sdk/transforms/CreateTest.java index 2dffdf63f6b3..c7e00ab47cb3 100644 --- a/sdks/java/core/src/test/java/org/apache/beam/sdk/transforms/CreateTest.java +++ b/sdks/java/core/src/test/java/org/apache/beam/sdk/transforms/CreateTest.java @@ -134,16 +134,17 @@ public void testCreateEmptyIterableWithCoder() { p.run(); } - static class Record implements Serializable {} + static class TestRecord implements Serializable {} - static class Record2 extends Record {} + static class TestRecord2 extends TestRecord {} - private static class RecordCoder extends AtomicCoder { + private static class TestRecordCoder extends AtomicCoder { @Override - public void encode(Record value, OutputStream outStream) throws CoderException, IOException {} + public void encode(TestRecord value, OutputStream outStream) + throws CoderException, IOException {} @Override - public Record decode(InputStream inStream) throws CoderException, IOException { + public TestRecord decode(InputStream inStream) throws CoderException, IOException { return null; } } @@ -154,7 +155,7 @@ public void testPolymorphicType() throws Exception { thrown.expectMessage(Matchers.containsString("Unable to infer a coder")); // Create won't infer a default coder in this case. - p.apply(Create.of(new Record(), new Record2())); + p.apply(Create.of(new TestRecord(), new TestRecord2())); p.run(); } @@ -309,11 +310,11 @@ public void testCreateTimestampedPolymorphicType() throws Exception { thrown.expectMessage(Matchers.containsString("Unable to infer a coder")); // Create won't infer a default coder in this case. - PCollection c = + PCollection c = p.apply( Create.timestamped( - TimestampedValue.of(new Record(), new Instant(0)), - TimestampedValue.of(new Record2(), new Instant(0)))); + TimestampedValue.of(new TestRecord(), new Instant(0)), + TimestampedValue.of(new TestRecord2(), new Instant(0)))); p.run(); @@ -322,24 +323,24 @@ public void testCreateTimestampedPolymorphicType() throws Exception { @Test public void testCreateTimestampedDefaultOutputCoderUsingCoder() throws Exception { - Coder coder = new RecordCoder(); - Create.TimestampedValues values = + Coder coder = new TestRecordCoder(); + Create.TimestampedValues values = Create.timestamped( - TimestampedValue.of(new Record(), new Instant(0)), - TimestampedValue.of(new Record2(), new Instant(0))) + TimestampedValue.of(new TestRecord(), new Instant(0)), + TimestampedValue.of(new TestRecord2(), new Instant(0))) .withCoder(coder); assertThat(p.apply(values).getCoder(), equalTo(coder)); } @Test public void testCreateTimestampedDefaultOutputCoderUsingTypeDescriptor() throws Exception { - Coder coder = new RecordCoder(); - p.getCoderRegistry().registerCoderForClass(Record.class, coder); - Create.TimestampedValues values = + Coder coder = new TestRecordCoder(); + p.getCoderRegistry().registerCoderForClass(TestRecord.class, coder); + Create.TimestampedValues values = Create.timestamped( - TimestampedValue.of(new Record(), new Instant(0)), - TimestampedValue.of(new Record2(), new Instant(0))) - .withType(new TypeDescriptor() {}); + TimestampedValue.of(new TestRecord(), new Instant(0)), + TimestampedValue.of(new TestRecord2(), new Instant(0))) + .withType(new TypeDescriptor() {}); assertThat(p.apply(values).getCoder(), equalTo(coder)); } @@ -460,26 +461,28 @@ public void testCreateGetName() { @Test public void testCreateDefaultOutputCoderUsingInference() throws Exception { - Coder coder = new RecordCoder(); - p.getCoderRegistry().registerCoderForClass(Record.class, coder); + Coder coder = new TestRecordCoder(); + p.getCoderRegistry().registerCoderForClass(TestRecord.class, coder); assertThat( - p.apply(Create.of(new Record(), new Record(), new Record())).getCoder(), equalTo(coder)); + p.apply(Create.of(new TestRecord(), new TestRecord(), new TestRecord())).getCoder(), + equalTo(coder)); } @Test public void testCreateDefaultOutputCoderUsingCoder() throws Exception { - Coder coder = new RecordCoder(); + Coder coder = new TestRecordCoder(); assertThat( - p.apply(Create.of(new Record(), new Record2()).withCoder(coder)).getCoder(), + p.apply(Create.of(new TestRecord(), new TestRecord2()).withCoder(coder)).getCoder(), equalTo(coder)); } @Test public void testCreateDefaultOutputCoderUsingTypeDescriptor() throws Exception { - Coder coder = new RecordCoder(); - p.getCoderRegistry().registerCoderForClass(Record.class, coder); - Create.Values values = - Create.of(new Record(), new Record2()).withType(new TypeDescriptor() {}); + Coder coder = new TestRecordCoder(); + p.getCoderRegistry().registerCoderForClass(TestRecord.class, coder); + Create.Values values = + Create.of(new TestRecord(), new TestRecord2()) + .withType(new TypeDescriptor() {}); assertThat(p.apply(values).getCoder(), equalTo(coder)); }