embulk 0.8.36-java → 0.10.25-java

data/embulk-core/src/test/java/org/embulk/spi/json/TestJsonParser.java

@@ -1,102 +0,0 @@
-package org.embulk.spi.json;
-
-import org.junit.Test;
-import org.msgpack.value.Value;
-import org.msgpack.value.ValueType;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
-
-public class TestJsonParser
-{
-    @Test
-    public void testString() throws Exception
-    {
-        final JsonParser parser = new JsonParser();
-        final Value msgpackValue = parser.parse("\"foobar\"");
-        assertFalse(msgpackValue.getValueType().isNumberType());
-        assertTrue(msgpackValue.getValueType().isStringType());
-        assertEquals("foobar", msgpackValue.asStringValue().toString());
-    }
-
-    @Test(expected = JsonParseException.class)
-    public void testStringUnquoted() throws Exception
-    {
-        final JsonParser parser = new JsonParser();
-        parser.parse("foobar");
-    }
-
-    @Test
-    public void testOrdinaryInteger() throws Exception
-    {
-        final JsonParser parser = new JsonParser();
-        final Value msgpackValue = parser.parse("12345");
-        assertTrue(msgpackValue.getValueType().isNumberType());
-        assertTrue(msgpackValue.getValueType().isIntegerType());
-        assertFalse(msgpackValue.getValueType().isFloatType());
-        assertFalse(msgpackValue.getValueType().isStringType());
-        assertEquals(12345, msgpackValue.asIntegerValue().asInt());
-    }
-
-    @Test
-    public void testExponentialInteger1() throws Exception
-    {
-        final JsonParser parser = new JsonParser();
-        final Value msgpackValue = parser.parse("12345e3");
-        assertTrue(msgpackValue.getValueType().isNumberType());
-        // TODO: Consider this needs to be an integer?
-        // See: https://github.com/embulk/embulk/issues/775
-        assertTrue(msgpackValue.getValueType().isFloatType());
-        assertFalse(msgpackValue.getValueType().isIntegerType());
-        assertFalse(msgpackValue.getValueType().isStringType());
-        assertEquals(12345000.0, msgpackValue.asFloatValue().toDouble(), 0.000000001);
-        // Not sure this |toString| is to be tested...
-        assertEquals("1.2345E7", msgpackValue.asFloatValue().toString());
-    }
-
-    @Test
-    public void testExponentialInteger2() throws Exception
-    {
-        final JsonParser parser = new JsonParser();
-        final Value msgpackValue = parser.parse("123e2");
-        assertTrue(msgpackValue.getValueType().isNumberType());
-        // TODO: Consider this needs to be an integer?
-        // See: https://github.com/embulk/embulk/issues/775
-        assertTrue(msgpackValue.getValueType().isFloatType());
-        assertFalse(msgpackValue.getValueType().isIntegerType());
-        assertFalse(msgpackValue.getValueType().isStringType());
-        assertEquals(12300.0, msgpackValue.asFloatValue().toDouble(), 0.000000001);
-        // Not sure this |toString| is to be tested...
-        assertEquals("12300.0", msgpackValue.asFloatValue().toString());
-    }
-
-    @Test
-    public void testOrdinaryFloat() throws Exception
-    {
-        final JsonParser parser = new JsonParser();
-        final Value msgpackValue = parser.parse("12345.12");
-        assertTrue(msgpackValue.getValueType().isNumberType());
-        assertTrue(msgpackValue.getValueType().isFloatType());
-        assertFalse(msgpackValue.getValueType().isIntegerType());
-        assertFalse(msgpackValue.getValueType().isStringType());
-        assertEquals(12345.12, msgpackValue.asFloatValue().toDouble(), 0.000000001);
-        // Not sure this |toString| is to be tested...
-        assertEquals("12345.12", msgpackValue.asFloatValue().toString());
-    }
-
-    @Test
-    public void testExponentialFloat() throws Exception
-    {
-        final JsonParser parser = new JsonParser();
-        final Value msgpackValue = parser.parse("1.234512E4");
-        assertTrue(msgpackValue.getValueType().isNumberType());
-        assertTrue(msgpackValue.getValueType().isFloatType());
-        assertFalse(msgpackValue.getValueType().isIntegerType());
-        assertFalse(msgpackValue.getValueType().isStringType());
-        assertEquals(12345.12, msgpackValue.asFloatValue().toDouble(), 0.000000001);
-        // Not sure this |toString| is to be tested...
-        assertEquals("12345.12", msgpackValue.asFloatValue().toString());
-    }
-}

data/embulk-core/src/test/java/org/embulk/spi/time/TestTimestamp.java

@@ -1,116 +0,0 @@
-package org.embulk.spi.time;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertFalse;
-
-import org.junit.Test;
-
-public class TestTimestamp
-{
-    @Test
-    public void testEqualsToTimestamp()
-    {
-        assertEqualsMethods(Timestamp.ofEpochSecond(0), Timestamp.ofEpochSecond(0));
-        assertEqualsMethods(Timestamp.ofEpochSecond(10), Timestamp.ofEpochSecond(10));
-        assertEqualsMethods(Timestamp.ofEpochSecond(10, 2), Timestamp.ofEpochSecond(10, 2));
-    }
-
-    private void assertEqualsMethods(Timestamp t1, Timestamp t2)
-    {
-        assertEquals(t1, t2);
-        assertEquals(t1.hashCode(), t2.hashCode());
-        assertEquals(0, t1.compareTo(t2));
-    }
-
-    @Test
-    public void testNotEqualsToTimestamp()
-    {
-        assertFalse(Timestamp.ofEpochSecond(0).equals(Timestamp.ofEpochSecond(1)));
-        assertFalse(Timestamp.ofEpochSecond(10).equals(Timestamp.ofEpochSecond(10, 2)));
-        assertFalse(Timestamp.ofEpochSecond(10, 2).equals(Timestamp.ofEpochSecond(20, 2)));
-    }
-
-    @Test
-    public void testEqualsToNull()
-    {
-        assertFalse(Timestamp.ofEpochSecond(0).equals(null));
-        assertFalse(Timestamp.ofEpochSecond(1, 2).equals(null));
-    }
-
-    @Test
-    public void testEqualsOtherClass()
-    {
-        assertFalse(Timestamp.ofEpochSecond(0).equals(new Object()));
-        assertFalse(Timestamp.ofEpochSecond(1, 2).equals("other"));
-    }
-
-    @Test
-    public void testAdjustMillisToNanos()
-    {
-        Timestamp t = Timestamp.ofEpochMilli(3);  // 3 msec = 3_000 usec == 3_000_000 nsec
-        assertEquals(0L, t.getEpochSecond());
-        assertEquals(3_000_000, t.getNano());
-    }
-
-    @Test
-    public void testAdjustMillisToSeconds()
-    {
-        Timestamp t = Timestamp.ofEpochMilli(3_000);  // 3_000 msec = 3 sec
-        assertEquals(3L, t.getEpochSecond());
-        assertEquals(0, t.getNano());
-    }
-
-    @Test
-    public void testAdjustNano()
-    {
-        Timestamp t = Timestamp.ofEpochSecond(0, 1_000_000_000);  // 1_000_000_000 nsec = 1_000_000 usec = 1_000 msec = 1 sec
-        assertEquals(1L, t.getEpochSecond());
-        assertEquals(0, t.getNano());
-    }
-
-    @Test
-    public void testCompareTo()
-    {
-        assertEquals(-1, Timestamp.ofEpochSecond(3).compareTo(Timestamp.ofEpochSecond(4)));
-        assertEquals(-1, Timestamp.ofEpochSecond(3).compareTo(Timestamp.ofEpochSecond(3, 4)));
-        assertEquals( 1, Timestamp.ofEpochSecond(4).compareTo(Timestamp.ofEpochSecond(3)));
-        assertEquals( 1, Timestamp.ofEpochSecond(3, 4).compareTo(Timestamp.ofEpochSecond(3)));
-    }
-
-    @Test
-    public void testToString()
-    {
-        assertEquals("1970-01-01 00:00:00 UTC", Timestamp.ofEpochSecond(0).toString());
-        assertEquals("2015-01-19 07:36:10 UTC", Timestamp.ofEpochSecond(1421652970).toString());
-        assertEquals("2015-01-19 07:36:10.100 UTC",       Timestamp.ofEpochSecond(1421652970, 100*1000*1000).toString());
-        assertEquals("2015-01-19 07:36:10.120 UTC",       Timestamp.ofEpochSecond(1421652970, 120*1000*1000).toString());
-        assertEquals("2015-01-19 07:36:10.123 UTC",       Timestamp.ofEpochSecond(1421652970, 123*1000*1000).toString());
-        assertEquals("2015-01-19 07:36:10.123400 UTC",    Timestamp.ofEpochSecond(1421652970, 123400*1000).toString());
-        assertEquals("2015-01-19 07:36:10.123450 UTC",    Timestamp.ofEpochSecond(1421652970, 123450*1000).toString());
-        assertEquals("2015-01-19 07:36:10.123456 UTC",    Timestamp.ofEpochSecond(1421652970, 123456*1000).toString());
-        assertEquals("2015-01-19 07:36:10.123456700 UTC", Timestamp.ofEpochSecond(1421652970, 123456700).toString());
-        assertEquals("2015-01-19 07:36:10.123456780 UTC", Timestamp.ofEpochSecond(1421652970, 123456780).toString());
-        assertEquals("2015-01-19 07:36:10.123456789 UTC", Timestamp.ofEpochSecond(1421652970, 123456789).toString());
-    }
-
-    @Test
-    public void testFromString()
-    {
-        checkToStringFromString(Timestamp.ofEpochSecond(0));
-        checkToStringFromString(Timestamp.ofEpochSecond(1421652970));
-        checkToStringFromString(Timestamp.ofEpochSecond(1421652970, 100*1000*1000));
-        checkToStringFromString(Timestamp.ofEpochSecond(1421652970, 120*1000*1000));
-        checkToStringFromString(Timestamp.ofEpochSecond(1421652970, 123*1000*1000));
-        checkToStringFromString(Timestamp.ofEpochSecond(1421652970, 123400*1000));
-        checkToStringFromString(Timestamp.ofEpochSecond(1421652970, 123450*1000));
-        checkToStringFromString(Timestamp.ofEpochSecond(1421652970, 123456*1000));
-        checkToStringFromString(Timestamp.ofEpochSecond(1421652970, 123456700));
-        checkToStringFromString(Timestamp.ofEpochSecond(1421652970, 123456780));
-        checkToStringFromString(Timestamp.ofEpochSecond(1421652970, 123456789));
-    }
-
-    private void checkToStringFromString(Timestamp timestamp)
-    {
-        assertEquals(timestamp, Timestamp.fromString(timestamp.toString()));
-    }
-}

data/embulk-core/src/test/java/org/embulk/spi/time/TestTimestampFormatterParser.java

@@ -1,75 +0,0 @@
-package org.embulk.spi.time;
-
-import org.junit.Rule;
-import org.junit.Before;
-import org.junit.Test;
-import com.google.common.base.Optional;
-import static org.junit.Assert.assertEquals;
-import org.embulk.config.Task;
-import org.embulk.config.Config;
-import org.embulk.config.ConfigSource;
-import org.embulk.spi.Exec;
-import org.embulk.EmbulkTestRuntime;
-
-public class TestTimestampFormatterParser
-{
-    @Rule
-    public EmbulkTestRuntime runtime = new EmbulkTestRuntime();
-
-    private interface FormatterTestTask
-            extends Task, TimestampFormatter.Task
-    { }
-
-    private interface ParserTestTask
-            extends Task, TimestampParser.Task
-    { }
-
-    @Test
-    public void testSimpleFormat() throws Exception
-    {
-        ConfigSource config = Exec.newConfigSource()
-            .set("default_timestamp_format", "%Y-%m-%d %H:%M:%S.%9N %z");  // %Z is OS-dependent
-        FormatterTestTask task = config.loadConfig(FormatterTestTask.class);
-
-        TimestampFormatter formatter = new TimestampFormatter(task, Optional.<TimestampFormatter.TimestampColumnOption>absent());
-        assertEquals("2014-11-19 02:46:29.123456000 +0000", formatter.format(Timestamp.ofEpochSecond(1416365189, 123456*1000)));
-    }
-
-    @Test
-    public void testSimpleParse() throws Exception
-    {
-        ConfigSource config = Exec.newConfigSource()
-            .set("default_timestamp_format", "%Y-%m-%d %H:%M:%S %z");  // %Z is OS-dependent
-        ParserTestTask task = config.loadConfig(ParserTestTask.class);
-
-        TimestampParser parser = TimestampParser.createTimestampParserForTesting(task);
-        assertEquals(Timestamp.ofEpochSecond(1416365189, 0), parser.parse("2014-11-19 02:46:29 +0000"));
-    }
-
-    @Test
-    public void testUnixtimeFormat() throws Exception
-    {
-        ConfigSource config = Exec.newConfigSource()
-            .set("default_timestamp_format", "%s");
-
-        FormatterTestTask ftask = config.loadConfig(FormatterTestTask.class);
-        TimestampFormatter formatter = new TimestampFormatter(ftask, Optional.<TimestampFormatter.TimestampColumnOption>absent());
-        assertEquals("1416365189", formatter.format(Timestamp.ofEpochSecond(1416365189)));
-
-        ParserTestTask ptask = config.loadConfig(ParserTestTask.class);
-        TimestampParser parser = TimestampParser.createTimestampParserForTesting(ptask);
-        assertEquals(Timestamp.ofEpochSecond(1416365189), parser.parse("1416365189"));
-    }
-
-    @Test
-    public void testDefaultDate() throws Exception
-    {
-        ConfigSource config = Exec.newConfigSource()
-            .set("default_timestamp_format", "%H:%M:%S %Z")
-            .set("default_date", "2016-02-03");
-
-        ParserTestTask ptask = config.loadConfig(ParserTestTask.class);
-        TimestampParser parser = TimestampParser.createTimestampParserForTesting(ptask);
-        assertEquals(Timestamp.ofEpochSecond(1454467589, 0), parser.parse("02:46:29 +0000"));
-    }
-}

data/embulk-core/src/test/java/org/embulk/spi/time/TestTimestampFormatterParserDeprecated.java

@@ -1,67 +0,0 @@
-package org.embulk.spi.time;
-
-import org.junit.Rule;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.assertEquals;
-import org.embulk.config.Config;
-import org.embulk.config.ConfigSource;
-import org.embulk.spi.Exec;
-import org.embulk.EmbulkTestRuntime;
-
-public class TestTimestampFormatterParserDeprecated
-{
-    @Rule
-    public EmbulkTestRuntime runtime = new EmbulkTestRuntime();
-
-    private interface FormatterTestTask
-            extends TimestampFormatter.FormatterTask
-    {
-        @Config("time_format")
-        public TimestampFormat getTimeFormat();
-    }
-
-    private interface ParserTestTask
-            extends TimestampParser.ParserTask
-    {
-        @Config("time_format")
-        public TimestampFormat getTimeFormat();
-    }
-
-    @Test
-    public void testSimpleFormat() throws Exception
-    {
-        ConfigSource config = Exec.newConfigSource()
-            .set("time_format", "%Y-%m-%d %H:%M:%S.%6N %z");
-        FormatterTestTask task = config.loadConfig(FormatterTestTask.class);
-
-        TimestampFormatter formatter = task.getTimeFormat().newFormatter(task);
-        assertEquals("2014-11-19 02:46:29.123456 +0000", formatter.format(Timestamp.ofEpochSecond(1416365189, 123456*1000)));
-    }
-
-    @Test
-    public void testSimpleParse() throws Exception
-    {
-        ConfigSource config = Exec.newConfigSource()
-            .set("time_format", "%Y-%m-%d %H:%M:%S.%N %z");
-        ParserTestTask task = config.loadConfig(ParserTestTask.class);
-
-        TimestampParser parser = task.getTimeFormat().newParser(task);
-        assertEquals(Timestamp.ofEpochSecond(1416365189, 123456*1000), parser.parse("2014-11-19 02:46:29.123456 +00:00"));
-    }
-
-    @Test
-    public void testUnixtimeFormat() throws Exception
-    {
-        ConfigSource config = Exec.newConfigSource()
-            .set("time_format", "%s");
-
-        FormatterTestTask ftask = config.loadConfig(FormatterTestTask.class);
-        TimestampFormatter formatter = ftask.getTimeFormat().newFormatter(ftask);
-        assertEquals("1416365189", formatter.format(Timestamp.ofEpochSecond(1416365189)));
-
-        ParserTestTask ptask = config.loadConfig(ParserTestTask.class);
-        TimestampParser parser = ptask.getTimeFormat().newParser(ptask);
-        assertEquals(Timestamp.ofEpochSecond(1416365189), parser.parse("1416365189"));
-    }
-}

data/embulk-core/src/test/java/org/embulk/spi/type/TestTypeSerDe.java

@@ -1,45 +0,0 @@
-package org.embulk.spi.type;
-
-import org.junit.Rule;
-import org.junit.Before;
-import org.junit.Test;
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.assertTrue;
-import com.google.inject.Inject;
-import com.fasterxml.jackson.annotation.JsonCreator;
-import com.fasterxml.jackson.annotation.JsonProperty;
-import org.embulk.EmbulkTestRuntime;
-
-public class TestTypeSerDe
-{
-    @Rule
-    public EmbulkTestRuntime runtime = new EmbulkTestRuntime();
-
-    private static class HasType
-    {
-        private Type type;
-        // TODO test TimestampType
-
-        @JsonCreator
-        public HasType(
-                @JsonProperty("type") Type type)
-        {
-            this.type = type;
-        }
-
-        @JsonProperty("type")
-        public Type getType()
-        {
-            return type;
-        }
-    }
-
-    @Test
-    public void testGetType()
-    {
-        HasType type = new HasType(StringType.STRING);
-        String json = runtime.getModelManager().writeObject(type);
-        HasType decoded = runtime.getModelManager().readObject(HasType.class, json);
-        assertTrue(StringType.STRING == decoded.getType());
-    }
-}

data/embulk-core/src/test/java/org/embulk/spi/unit/TestByteSize.java

@@ -1,79 +0,0 @@
-package org.embulk.spi.unit;
-
-import static org.junit.Assert.assertEquals;
-import static org.junit.Assert.fail;
-import org.junit.Test;
-
-public class TestByteSize
-{
-    @Test
-    public void testUnitPatterns()
-    {
-        assertByteSize(42L, "42");
-        assertByteSize(42L, "42B");
-        assertByteSize(42L*(1L << 10), "42KB");
-        assertByteSize(42L*(1L << 20), "42MB");
-        assertByteSize(42L*(1L << 30), "42GB");
-        assertByteSize(42L*(1L << 40), "42TB");
-        assertByteSize(42L*(1L << 50), "42PB");
-        assertByteSize(42L, "42 B");
-        assertByteSize(42L*(1L << 10), "42 KB");
-    }
-
-    @Test
-    public void testUnknownUnits()
-    {
-        assertInvalidByteSize("42XB");
-        assertInvalidByteSize("42 XB");
-    }
-
-    @Test
-    public void testInvalidPatterns()
-    {
-        assertInvalidByteSize(" 42");
-        assertInvalidByteSize("42  B");
-        assertInvalidByteSize("42 B ");
-        assertInvalidByteSize("42B ");
-        assertInvalidByteSize("42  KB");
-        assertInvalidByteSize("42 KB ");
-        assertInvalidByteSize("42KB ");
-    }
-
-    @Test
-    public void testInvalidValues()
-    {
-        assertInvalidByteSize("9223372036854775KB");
-    }
-
-    @Test
-    public void testToString()
-    {
-        assertByteSizeString("42B", "42 B");
-        assertByteSizeString("42KB", "42 KB");
-        assertByteSizeString("42MB", "42 MB");
-        assertByteSizeString("42GB", "42 GB");
-        assertByteSizeString("42TB", "42 TB");
-        assertByteSizeString("42PB", "42 PB");
-        assertByteSizeString("42.20KB", "42.2 KB");
-        assertByteSizeString("42.33KB", "42.33KB");
-    }
-
-    private static void assertByteSize(long bytes, String string)
-    {
-        assertEquals(bytes, ByteSize.parseByteSize(string).getBytes());
-    }
-
-    private static void assertByteSizeString(String expected, String string)
-    {
-        assertEquals(expected, ByteSize.parseByteSize(string).toString());
-    }
-
-    private static void assertInvalidByteSize(String string)
-    {
-        try {
-            ByteSize.parseByteSize(string);
-            fail();
-        } catch (IllegalArgumentException ex) {
-        }
-    }
-}