private ModelOutput<Object> writer( BinaryStreamFormat<Object> format, OutputStream output) throws IOException, InterruptedException { return format.createOutput(format.getSupportedType(), "testing", output); }
private static byte[] write(ModelLoader loaded, ModelWrapper... objects) { String name = objects[0].getModelClass().getSimpleName(); BinaryStreamFormat<Object> unsafe = unsafe(loaded.newObject("text", name + "CsvTextFormat")); ByteArrayOutputStream output = new ByteArrayOutputStream(); try (ModelOutput<Object> writer = unsafe.createOutput(unsafe.getSupportedType(), "testing", output)) { for (ModelWrapper object : objects) { writer.write(object.unwrap()); } } catch (IOException | InterruptedException e) { throw new AssertionError(e); } return output.toByteArray(); }
private static byte[] write(ModelLoader loaded, ModelWrapper... objects) { String name = objects[0].getModelClass().getSimpleName(); BinaryStreamFormat<Object> unsafe = unsafe(loaded.newObject(SEGMENT, name + "JsonFormat")); ByteArrayOutputStream output = new ByteArrayOutputStream(); try (ModelOutput<Object> writer = unsafe.createOutput(unsafe.getSupportedType(), "testing", output)) { for (ModelWrapper object : objects) { writer.write(object.unwrap()); } } catch (IOException | InterruptedException e) { throw new AssertionError(e); } return output.toByteArray(); }
private byte[] write(ModelLoader loaded, ModelWrapper... objects) { String name = objects[0].getModelClass().getSimpleName(); BinaryStreamFormat<Object> unsafe = unsafe(loaded.newObject("text", name + "TabularTextFormat")); ByteArrayOutputStream output = new ByteArrayOutputStream(); try (ModelOutput<Object> writer = unsafe.createOutput(unsafe.getSupportedType(), "testing", output)) { for (ModelWrapper object : objects) { writer.write(object.unwrap()); } } catch (IOException | InterruptedException e) { throw new AssertionError(e); } return output.toByteArray(); }
private void writeError(ModelLoader loaded, ModelWrapper object) { String name = object.getModelClass().getSimpleName(); BinaryStreamFormat<Object> unsafe = unsafe(loaded.newObject("text", name + "TabularTextFormat")); ByteArrayOutputStream output = new ByteArrayOutputStream(); try (ModelOutput<Object> writer = unsafe.createOutput(unsafe.getSupportedType(), "testing", output)) { writer.write(object.unwrap()); fail(); } catch (IOException e) { // ok. } catch (InterruptedException e) { throw new AssertionError(e); } }
/** * with implicit field. * @throws Exception if failed */ @Test public void implicit_field_name() throws Exception { ModelLoader loaded = generateJava("implicit_field_name"); ModelWrapper model = loaded.newModel("Model"); BinaryStreamFormat<Object> support = unsafe(loaded.newObject("csv", "ModelCsvFormat")); ByteArrayOutputStream output = new ByteArrayOutputStream(); try (ModelOutput<Object> writer = support.createOutput(model.unwrap().getClass(), "hello", output)) { model.set("value", new Text("Hello, world!")); writer.write(model.unwrap()); } String[][] results = parse(1, new String(output.toByteArray(), "UTF-8")); assertThat(results, is(new String[][] { {"value"}, {"Hello, world!"}, })); }
/** * with header. * @throws Exception if failed */ @Test public void header() throws Exception { ModelLoader loaded = generateJava("field_name"); ModelWrapper model = loaded.newModel("Model"); BinaryStreamFormat<Object> support = unsafe(loaded.newObject("csv", "ModelCsvFormat")); ByteArrayOutputStream output = new ByteArrayOutputStream(); try (ModelOutput<Object> writer = support.createOutput(model.unwrap().getClass(), "hello", output)) { model.set("value", new Text("Hello, world!")); writer.write(model.unwrap()); } String[][] results = parse(1, new String(output.toByteArray(), "UTF-8")); assertThat(results, is(new String[][] { {"title"}, {"Hello, world!"}, })); }
/** * with force header. * @throws Exception if failed */ @Test public void force_header() throws Exception { ModelLoader loaded = generateJava("force_header"); ModelWrapper model = loaded.newModel("Model"); BinaryStreamFormat<Object> support = unsafe(loaded.newObject("csv", "ModelCsvFormat")); ByteArrayOutputStream output = new ByteArrayOutputStream(); try (ModelOutput<Object> writer = support.createOutput(model.unwrap().getClass(), "hello", output)) { model.set("value", new Text("Hello, world!")); writer.write(model.unwrap()); } String[][] results = parse(1, new String(output.toByteArray(), "UTF-8")); assertThat(results, is(new String[][] { {"title"}, {"Hello, world!"}, })); }
/** * with attributes. * @throws Exception if failed */ @Test public void attributes() throws Exception { ModelLoader loaded = generateJava("attributes"); ModelWrapper model = loaded.newModel("Model"); model.set("text_value", new Text("\u3042\u3044\u3046\u3048\u304a")); model.set("true_value", true); model.set("false_value", false); model.set("date_value", new Date(2011, 10, 11)); model.set("date_time_value", new DateTime(2011, 1, 2, 13, 14, 15)); BinaryStreamFormat<Object> support = unsafe(loaded.newObject("csv", "ModelCsvFormat")); ByteArrayOutputStream output = new ByteArrayOutputStream(); try (ModelOutput<Object> writer = support.createOutput(model.unwrap().getClass(), "hello", output)) { writer.write(model.unwrap()); } String[][] results = parse(5, new String(dump(new GZIPInputStream(new ByteArrayInputStream(output.toByteArray()))), "ISO-2022-jp")); assertThat(results, is(new String[][] { {"text_value", "true_value", "false_value", "date_value", "date_time_value"}, {"\u3042\u3044\u3046\u3048\u304a", "T", "F", "2011/10/11", "2011/01/02+13:14:15"}, })); }
/** * quoted. * @throws Exception if failed */ @Test public void quote() throws Exception { ModelLoader loaded = generateJava("quote"); ModelWrapper model = loaded.newModel("Simple"); BinaryStreamFormat<?> support = (BinaryStreamFormat<?>) loaded.newObject("csv", "SimpleCsvFormat"); BinaryStreamFormat<Object> unsafe = unsafe(support); ByteArrayOutputStream output = new ByteArrayOutputStream(); try (ModelOutput<Object> writer = unsafe.createOutput(model.unwrap().getClass(), "hello", output)) { model.set("value", new Text("hello-world")); writer.write(model.unwrap()); model.set("value", new Text("hello,world")); writer.write(model.unwrap()); } assertThat(scan(output.toByteArray()), contains("\"hello-world\"", "\"hello,world\"")); }
/** * With compression. * @throws Exception if failed */ @Test public void compression() throws Exception { ModelLoader loaded = generateJava("compress"); ModelWrapper model = loaded.newModel("Compress"); BinaryStreamFormat<?> support = (BinaryStreamFormat<?>) loaded.newObject("csv", "CompressCsvFormat"); assertThat(support.getSupportedType(), is((Object) model.unwrap().getClass())); BinaryStreamFormat<Object> unsafe = unsafe(support); assertThat(unsafe, is(instanceOf(Configurable.class))); model.set("value", new Text("hello")); ByteArrayOutputStream output = new ByteArrayOutputStream(); try (ModelOutput<Object> writer = unsafe.createOutput(model.unwrap().getClass(), "hello", output)) { writer.write(model.unwrap()); } assertThat( scan(dump(new GZIPInputStream(new ByteArrayInputStream(output.toByteArray())))), is(Arrays.asList("hello"))); Object buffer = loaded.newModel("Compress").unwrap(); try (ModelInput<Object> reader = unsafe.createInput(model.unwrap().getClass(), "hello", in(output), 0, size(output))) { assertThat(reader.readTo(buffer), is(true)); assertThat(buffer, is(model.unwrap())); assertThat(reader.readTo(buffer), is(false)); } }
/** * unlimited range. * @throws Exception if failed */ @Test public void unlimited() throws Exception { ModelLoader loaded = generateJava("simple"); ModelWrapper model = loaded.newModel("Simple"); BinaryStreamFormat<?> support = (BinaryStreamFormat<?>) loaded.newObject("csv", "SimpleCsvFormat"); assertThat(support.getSupportedType(), is((Object) model.unwrap().getClass())); BinaryStreamFormat<Object> unsafe = unsafe(support); assertThat(unsafe, is(not(instanceOf(Configurable.class)))); model.set("value", new Text("hello-world")); ByteArrayOutputStream output = new ByteArrayOutputStream(); try (ModelOutput<Object> writer = unsafe.createOutput(model.unwrap().getClass(), "hello", output)) { writer.write(model.unwrap()); } assertThat(scan(output.toByteArray()), is(Arrays.asList("hello-world"))); Object buffer = loaded.newModel("Simple").unwrap(); try (ModelInput<Object> reader = unsafe.createInput(model.unwrap().getClass(), "hello", in(output), 0, -1)) { assertThat(reader.readTo(buffer), is(true)); assertThat(buffer, is(model.unwrap())); assertThat(reader.readTo(buffer), is(false)); } }
/** * A simple case. * @throws Exception if failed */ @Test public void simple() throws Exception { ModelLoader loaded = generateJava("simple"); ModelWrapper model = loaded.newModel("Simple"); BinaryStreamFormat<?> support = (BinaryStreamFormat<?>) loaded.newObject("csv", "SimpleCsvFormat"); assertThat(support.getSupportedType(), is((Object) model.unwrap().getClass())); BinaryStreamFormat<Object> unsafe = unsafe(support); assertThat(unsafe, is(not(instanceOf(Configurable.class)))); model.set("value", new Text("hello-world")); ByteArrayOutputStream output = new ByteArrayOutputStream(); try (ModelOutput<Object> writer = unsafe.createOutput(model.unwrap().getClass(), "hello", output)) { writer.write(model.unwrap()); } assertThat(scan(output.toByteArray()), is(Arrays.asList("hello-world"))); Object buffer = loaded.newModel("Simple").unwrap(); try (ModelInput<Object> reader = unsafe.createInput(model.unwrap().getClass(), "hello", in(output), 0, size(output))) { assertThat(reader.readTo(buffer), is(true)); assertThat(buffer, is(model.unwrap())); assertThat(reader.readTo(buffer), is(false)); } }
/** * fragmentation is restricted. * @throws Exception if failed */ @Test public void fragmentation_restricted() throws Exception { ModelLoader loaded = generateJava("fragmentation_restricted"); ModelWrapper model = loaded.newModel("Tuple"); BinaryStreamFormat<?> support = (BinaryStreamFormat<?>) loaded.newObject("csv", "TupleCsvFormat"); BinaryStreamFormat<Object> unsafe = unsafe(support); model.set("f1", new Text("Hello1")); model.set("f2", new Text("Hello1")); model.set("f3", new Text("Hello1")); ByteArrayOutputStream output = new ByteArrayOutputStream(); try (ModelOutput<Object> writer = unsafe.createOutput(model.unwrap().getClass(), "hello", output)) { writer.write(model.unwrap()); } try { unsafe.createInput(model.unwrap().getClass(), "hello", in(output), 1, size(output)); fail(); } catch (Exception e) { // ok. } }
/** * with ignored property. * @throws Exception if failed */ @Test public void ignore() throws Exception { ModelLoader loaded = generateJava("ignore"); ModelWrapper model = loaded.newModel("Model"); model.set("value", new Text("Hello, world!")); model.set("ignored", new Text("ignored")); ModelWrapper buffer = loaded.newModel("Model"); BinaryStreamFormat<Object> support = unsafe(loaded.newObject("csv", "ModelCsvFormat")); ByteArrayOutputStream output = new ByteArrayOutputStream(); try (ModelOutput<Object> writer = support.createOutput(model.unwrap().getClass(), "hello", output)) { writer.write(model.unwrap()); } try (ModelInput<Object> reader = support.createInput(model.unwrap().getClass(), "testing", in(output), 0, size(output))) { assertThat(reader.readTo(buffer.unwrap()), is(true)); assertThat(buffer.getOption("value"), is((Object) new StringOption("Hello, world!"))); assertThat(buffer.getOption("ignored"), is((Object) new StringOption())); assertThat(reader.readTo(buffer.unwrap()), is(false)); } }
/** * with file name. * @throws Exception if failed */ @Test public void file_name() throws Exception { ModelLoader loaded = generateJava("file_name"); ModelWrapper model = loaded.newModel("Model"); ModelWrapper buffer = loaded.newModel("Model"); BinaryStreamFormat<Object> support = unsafe(loaded.newObject("csv", "ModelCsvFormat")); assertThat(support.getMinimumFragmentSize(), is(greaterThan(0L))); ByteArrayOutputStream output = new ByteArrayOutputStream(); try (ModelOutput<Object> writer = support.createOutput(model.unwrap().getClass(), "hello", output)) { model.set("value", new Text("Hello, world!")); writer.write(model.unwrap()); } try (ModelInput<Object> reader = support.createInput(model.unwrap().getClass(), "testing", in(output), 0, size(output))) { assertThat(reader.readTo(buffer.unwrap()), is(true)); assertThat(buffer.getOption("value"), is((Object) new StringOption("Hello, world!"))); assertThat(buffer.getOption("path"), is((Object) new StringOption("testing"))); assertThat(reader.readTo(buffer.unwrap()), is(false)); } }
/** * simple case. * @throws Exception if failed */ @Test public void simple() throws Exception { ModelLoader loaded = generateJavaFromLines(new String[] { "@directio.text.tabular", "simple = { value : TEXT; };", }); ModelWrapper model = loaded.newModel("Simple") .setOption("value", new StringOption("Hello, world!")); BinaryStreamFormat<?> support = (BinaryStreamFormat<?>) loaded.newObject("text", "SimpleTabularTextFormat"); assertThat(support.getSupportedType(), is((Object) model.unwrap().getClass())); assertThat(support.getMinimumFragmentSize(), is(not(-1L))); BinaryStreamFormat<Object> unsafe = unsafe(support); ByteArrayOutputStream output = new ByteArrayOutputStream(); try (ModelOutput<Object> writer = unsafe.createOutput(unsafe.getSupportedType(), "hello", output)) { writer.write(model.unwrap()); } assertThat(text(output), is("Hello, world!\n")); Object buffer = loaded.newModel("Simple").unwrap(); try (ModelInput<Object> reader = unsafe.createInput(unsafe.getSupportedType(), "hello", in(output))) { assertThat(reader.readTo(buffer), is(true)); assertThat(buffer, is(model.unwrap())); assertThat(reader.readTo(buffer), is(false)); } }
/** * with line number. * @throws Exception if failed */ @Test public void line_number() throws Exception { ModelLoader loaded = generateJava("line_number"); ModelWrapper model = loaded.newModel("Model"); model.set("value", new Text("Hello\nworld!")); ModelWrapper buffer = loaded.newModel("Model"); BinaryStreamFormat<Object> support = unsafe(loaded.newObject("csv", "ModelCsvFormat")); ByteArrayOutputStream output = new ByteArrayOutputStream(); try (ModelOutput<Object> writer = support.createOutput(model.unwrap().getClass(), "hello", output)) { writer.write(model.unwrap()); writer.write(model.unwrap()); } try (ModelInput<Object> reader = support.createInput(model.unwrap().getClass(), "testing", in(output), 0, size(output))) { assertThat(reader.readTo(buffer.unwrap()), is(true)); assertThat(buffer.getOption("value"), is((Object) new StringOption("Hello\nworld!"))); assertThat(buffer.getOption("number"), is((Object) new IntOption(1))); assertThat(reader.readTo(buffer.unwrap()), is(true)); assertThat(buffer.getOption("value"), is((Object) new StringOption("Hello\nworld!"))); assertThat(buffer.getOption("number"), is((Object) new IntOption(3))); assertThat(reader.readTo(buffer.unwrap()), is(false)); } }
/** * with record number. * @throws Exception if failed */ @Test public void record_number() throws Exception { ModelLoader loaded = generateJava("record_number"); ModelWrapper model = loaded.newModel("Model"); model.set("value", new Text("Hello\nworld!")); ModelWrapper buffer = loaded.newModel("Model"); BinaryStreamFormat<Object> support = unsafe(loaded.newObject("csv", "ModelCsvFormat")); ByteArrayOutputStream output = new ByteArrayOutputStream(); try (ModelOutput<Object> writer = support.createOutput(model.unwrap().getClass(), "hello", output)) { writer.write(model.unwrap()); writer.write(model.unwrap()); } try (ModelInput<Object> reader = support.createInput(model.unwrap().getClass(), "testing", in(output), 0, size(output))) { assertThat(reader.readTo(buffer.unwrap()), is(true)); assertThat(buffer.getOption("value"), is((Object) new StringOption("Hello\nworld!"))); assertThat(buffer.getOption("number"), is((Object) new LongOption(1))); assertThat(reader.readTo(buffer.unwrap()), is(true)); assertThat(buffer.getOption("value"), is((Object) new StringOption("Hello\nworld!"))); assertThat(buffer.getOption("number"), is((Object) new LongOption(2))); assertThat(reader.readTo(buffer.unwrap()), is(false)); } }
/** * simple case. * @throws Exception if failed */ @Test public void simple() throws Exception { ModelLoader loaded = generateJavaFromLines(new String[] { "@directio.json", "simple = { value : TEXT; };", }); ModelWrapper model = loaded.newModel("Simple") .setOption("value", new StringOption("Hello, world!")); BinaryStreamFormat<?> support = (BinaryStreamFormat<?>) loaded.newObject(SEGMENT, "SimpleJsonFormat"); assertThat(support.getSupportedType(), is((Object) model.unwrap().getClass())); assertThat(support.getMinimumFragmentSize(), is(lessThan(0L))); BinaryStreamFormat<Object> unsafe = unsafe(support); ByteArrayOutputStream output = new ByteArrayOutputStream(); try (ModelOutput<Object> writer = unsafe.createOutput(unsafe.getSupportedType(), "hello", output)) { writer.write(model.unwrap()); } assertThat(parse(output.toByteArray()), contains(map("value", "'Hello, world!'"))); Object buffer = loaded.newModel("Simple").unwrap(); try (ModelInput<Object> reader = unsafe.createInput(unsafe.getSupportedType(), "hello", in(output))) { assertThat(reader.readTo(buffer), is(true)); assertThat(buffer, is(model.unwrap())); assertThat(reader.readTo(buffer), is(false)); } }