EncoderTest.java

/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
package com.android.tools.rpclib.binary;

import junit.framework.TestCase;
import org.jetbrains.annotations.NotNull;
import org.junit.Assert;

import java.io.ByteArrayOutputStream;
import java.io.IOException;

public class EncoderTest extends TestCase {
  public void testEncodeBool() throws IOException {
    final boolean[] input = new boolean[]{true, false};
    final byte[] expected = new byte[]{(byte)0x01, (byte)0x00};

    ByteArrayOutputStream output = new ByteArrayOutputStream(expected.length);
    Encoder e = new Encoder(output);

    for (boolean bool : input) {
      e.bool(bool);
    }
    Assert.assertArrayEquals(expected, output.toByteArray());
  }

  public void testEncodeInt8() throws IOException {
    final byte[] input = new byte[]{0, 127, -128, -1};
    final byte[] expected = new byte[]{(byte)0x00, (byte)0x7f, (byte)0x80, (byte)0xff};

    ByteArrayOutputStream output = new ByteArrayOutputStream(expected.length);
    Encoder e = new Encoder(output);

    for (byte s8 : input) {
      e.int8(s8);
    }
    Assert.assertArrayEquals(expected, output.toByteArray());
  }

  public void testEncodeUint8() throws IOException {
    final short[] input = new short[]{0x00, 0x7f, 0x80, 0xff};
    final byte[] expected = new byte[]{(byte)0x00, (byte)0x7f, (byte)0x80, (byte)0xff};

    ByteArrayOutputStream output = new ByteArrayOutputStream(expected.length);
    Encoder e = new Encoder(output);

    for (short u8 : input) {
      e.uint8(u8);
    }
    Assert.assertArrayEquals(expected, output.toByteArray());
  }

  public void testEncodeInt16() throws IOException {
    final short[] input = new short[]{0, 32767, -32768, -1};
    final byte[] expected = new byte[]{
      (byte)0x00,
      (byte)0xc0, (byte)0xff, (byte)0xfe,
      (byte)0xc0, (byte)0xff, (byte)0xff,
      (byte)0x01,
    };

    ByteArrayOutputStream output = new ByteArrayOutputStream(expected.length);
    Encoder e = new Encoder(output);

    for (short s16 : input) {
      e.int16(s16);
    }
    Assert.assertArrayEquals(expected, output.toByteArray());
  }

  public void testEncodeUint16() throws IOException {
    final int[] input = new int[]{0, 0xbeef, 0xc0de};
    final byte[] expected = new byte[]{
      (byte)0x00,
      (byte)0xc0, (byte)0xbe, (byte)0xef,
      (byte)0xc0, (byte)0xc0, (byte)0xde
    };

    ByteArrayOutputStream output = new ByteArrayOutputStream(expected.length);
    Encoder e = new Encoder(output);

    for (int u16 : input) {
      e.uint16(u16);
    }
    Assert.assertArrayEquals(expected, output.toByteArray());
  }

  public void testEncodeInt32() throws IOException {
    final int[] input = new int[]{0, 2147483647, -2147483648, -1};
    final byte[] expected = new byte[]{
      (byte)0x00,
      (byte)0xf0, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xfe,
      (byte)0xf0, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff,
      (byte)0x01
    };

    ByteArrayOutputStream output = new ByteArrayOutputStream(expected.length);
    Encoder e = new Encoder(output);

    for (int s32 : input) {
      e.int32(s32);
    }
    Assert.assertArrayEquals(expected, output.toByteArray());
  }

  public void testEncodeUint32() throws IOException {
    final long[] input = new long[]{0, 0x01234567, 0x10abcdef};
    final byte[] expected = new byte[]{
      (byte)0x00,
      (byte)0xe1, (byte)0x23, (byte)0x45, (byte)0x67,
      (byte)0xf0, (byte)0x10, (byte)0xab, (byte)0xcd, (byte)0xef
    };

    ByteArrayOutputStream output = new ByteArrayOutputStream(expected.length);
    Encoder e = new Encoder(output);

    for (long u32 : input) {
      e.uint32(u32);
    }
    Assert.assertArrayEquals(expected, output.toByteArray());
  }

  public void testEncodeInt64() throws IOException {
    final long[] input = new long[]{0L, 9223372036854775807L, -9223372036854775808L, -1L};
    final byte[] expected = new byte[]{
      (byte)0x00,
      (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xfe,
      (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff, (byte)0xff,(byte) 0xff,
      (byte)0x01
    };

    ByteArrayOutputStream output = new ByteArrayOutputStream(expected.length);
    Encoder e = new Encoder(output);

    for (long s64 : input) {
      e.int64(s64);
    }
    Assert.assertArrayEquals(expected, output.toByteArray());
  }

  public void testEncodeUint64() throws IOException {
    final long[] input = new long[]{0L, 0x0123456789abcdefL, 0xfedcba9876543210L};
    final byte[] expected = new byte[]{
      (byte)0x00,
      (byte)0xff, (byte)0x01, (byte)0x23, (byte)0x45, (byte)0x67, (byte)0x89, (byte)0xab, (byte)0xcd, (byte)0xef,
      (byte)0xff, (byte)0xfe, (byte)0xdc, (byte)0xba, (byte)0x98, (byte)0x76, (byte)0x54, (byte)0x32, (byte)0x10
    };

    ByteArrayOutputStream output = new ByteArrayOutputStream(expected.length);
    Encoder e = new Encoder(output);

    for (long u64 : input) {
      e.uint64(u64);
    }
    Assert.assertArrayEquals(expected, output.toByteArray());
  }

  public void testEncodeFloat32() throws IOException {
    final float[] input = new float[]{0.F, 1.F, 64.5F};
    final byte[] expected = new byte[]{
      (byte)0x00,
      (byte)0xc0, (byte)0x80, (byte)0x3f,
      (byte)0xc0,(byte) 0x81, (byte)0x42,
    };

    ByteArrayOutputStream output = new ByteArrayOutputStream(expected.length);
    Encoder e = new Encoder(output);

    for (float f32 : input) {
      e.float32(f32);
    }
    Assert.assertArrayEquals(expected, output.toByteArray());
  }

  public void testEncodeFloat64() throws IOException {
    final double[] input = new double[]{0.D, 1.D, 64.5D};
    final byte[] expected = new byte[]{
      (byte)0x00,
      (byte)0xc0, (byte)0xf0, (byte)0x3f,
      (byte)0xe0, (byte)0x20, (byte)0x50, (byte)0x40,
    };

    ByteArrayOutputStream output = new ByteArrayOutputStream(expected.length);
    Encoder e = new Encoder(output);

    for (double f64 : input) {
      e.float64(f64);
    }
    Assert.assertArrayEquals(expected, output.toByteArray());
  }

  public void testEncodeString() throws IOException {
    final String[] input = new String[]{null, "Hello", "", "World", "こんにちは世界"};
    final byte[] expected = new byte[]{
      0x00, // null string
      0x05, 'H', 'e', 'l', 'l', 'o',
      0x00, // empty string
      0x05, 'W', 'o', 'r', 'l', 'd',

      0x15,
      (byte)0xe3, (byte)0x81, (byte)0x93, (byte)0xe3, (byte)0x82, (byte)0x93, (byte)0xe3,
      (byte)0x81, (byte)0xab, (byte)0xe3, (byte)0x81, (byte)0xa1, (byte)0xe3, (byte)0x81,
      (byte)0xaf, (byte)0xe4, (byte)0xb8, (byte)0x96, (byte)0xe7, (byte)0x95, (byte)0x8c
    };

    ByteArrayOutputStream output = new ByteArrayOutputStream(expected.length);
    Encoder e = new Encoder(output);

    for (String str : input) {
      e.string(str);
    }
    Assert.assertArrayEquals(expected, output.toByteArray());
  }

  public void testEncodeObject() throws IOException {
    final byte[] dummyObjectTypeIDBytes = new byte[]{
      0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
      0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09
    };
    class DummyObject implements BinaryObject {
      final String dummy = "dummy";
      @Override
      public ObjectTypeID type() {
        return new ObjectTypeID(dummyObjectTypeIDBytes);
      }
      @Override
      public void decode(@NotNull Decoder d) throws IOException {
        assert d.string().equals(dummy);
      }
      @Override
      public void encode(@NotNull Encoder e) throws IOException {
        e.string(dummy);
      }
    }

    final BinaryObject dummyObject = new DummyObject();
    final BinaryObject[] input = new BinaryObject[]{null, dummyObject, dummyObject};
    byte[] expected = null;

    ByteArrayOutputStream expectedStream = new ByteArrayOutputStream();

    // null BinaryObject:
    expectedStream.write(new byte[]{(byte)0x00}); // BinaryObject.NULL_ID

    // dummyObject:
    expectedStream.write(new byte[]{0x01}); // dummyObject reference
    expectedStream.write(dummyObjectTypeIDBytes); // dummyObject.type()
    expectedStream.write(new byte[]{0x05, 'd', 'u', 'm', 'm', 'y'});

    // dummyObject again, only by reference this time:
    expectedStream.write(new byte[]{0x01}); // dummyObject reference
    expected = expectedStream.toByteArray();

    ByteArrayOutputStream output = new ByteArrayOutputStream(expected.length);
    Encoder e = new Encoder(output);

    for (BinaryObject obj : input) {
      e.object(obj);
    }
    Assert.assertArrayEquals(expected, output.toByteArray());
  }
}