tests/tests/proto/src/android/util/proto/cts/ProtoOutputStreamBoolTest.java - platform/cts - Git at Google

 /*
  * Copyright (C) 2016 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 android.util.proto.cts;

 import android.util.proto.ProtoOutputStream;
 import android.util.proto.cts.nano.Test;

 import com.google.protobuf.nano.MessageNano;
 import junit.framework.TestCase;
 import org.junit.Assert;

 /**
  * Test the bool methods on the ProtoOutputStream class.
  */
 public class ProtoOutputStreamBoolTest extends TestCase {

     // ----------------------------------------------------------------------
     //  writeBool
     // ----------------------------------------------------------------------

     /**
      * Test writeBool.
      */
     public void testWrite() throws Exception {
         testWrite(0);
         testWrite(1);
         testWrite(5);
     }

     /**
      * Implementation of testWrite with a given chunkSize.
      */
     public void testWrite(int chunkSize) throws Exception {
         final ProtoOutputStream po = new ProtoOutputStream(chunkSize);
         final long fieldFlags = ProtoOutputStream.FIELD_COUNT_SINGLE | ProtoOutputStream.FIELD_TYPE_BOOL;

         po.writeBool(ProtoOutputStream.makeFieldId(1, fieldFlags), false);
         po.writeBool(ProtoOutputStream.makeFieldId(2, fieldFlags), true);

         final byte[] result = po.getBytes();
         Assert.assertArrayEquals(new byte[] {
                 // 1 -> 0 - default value, not written
                 // 2 -> 1
                 (byte)0x10,
                 (byte)0x01,
             }, result);
     }

     /**
      * Test that writing a with ProtoOutputStream matches, and can be read by standard proto.
      */
     public void testWriteCompat() throws Exception {
         testWriteCompat(false);
         testWriteCompat(true);
     }

     /**
      * Implementation of testWriteCompat with a given value.
      */
     public void testWriteCompat(boolean val) throws Exception {
         final int fieldId = 130;
         final long fieldFlags = ProtoOutputStream.FIELD_COUNT_SINGLE | ProtoOutputStream.FIELD_TYPE_BOOL;

         final Test.All all = new Test.All();
         final ProtoOutputStream po = new ProtoOutputStream(0);

         all.boolField = val;
         po.writeBool(ProtoOutputStream.makeFieldId(fieldId, fieldFlags), val);

         final byte[] result = po.getBytes();
         final byte[] expected = MessageNano.toByteArray(all);

         Assert.assertArrayEquals(expected, result);

         final Test.All readback = Test.All.parseFrom(result);

         assertEquals(val, readback.boolField);
     }

     // ----------------------------------------------------------------------
     //  writeRepeatedBool
     // ----------------------------------------------------------------------

     /**
      * Test writeRepeatedBool.
      */
     public void testRepeated() throws Exception {
         testRepeated(0);
         testRepeated(1);
         testRepeated(5);
     }

     /**
      * Implementation of testRepeated with a given chunkSize.
      */
     public void testRepeated(int chunkSize) throws Exception {
         final ProtoOutputStream po = new ProtoOutputStream(chunkSize);
         final long fieldFlags = ProtoOutputStream.FIELD_COUNT_REPEATED | ProtoOutputStream.FIELD_TYPE_BOOL;

         po.writeRepeatedBool(ProtoOutputStream.makeFieldId(1, fieldFlags), false);
         po.writeRepeatedBool(ProtoOutputStream.makeFieldId(2, fieldFlags), true);

         po.writeRepeatedBool(ProtoOutputStream.makeFieldId(1, fieldFlags), false);
         po.writeRepeatedBool(ProtoOutputStream.makeFieldId(2, fieldFlags), true);

         final byte[] result = po.getBytes();
         Assert.assertArrayEquals(new byte[] {
                 // 1 -> 0 - default value, written when repeated
                 (byte)0x08,
                 (byte)0x00,
                 // 2 -> 1
                 (byte)0x10,
                 (byte)0x01,

                 // 1 -> 0 - default value, written when repeated
                 (byte)0x08,
                 (byte)0x00,
                 // 2 -> 1
                 (byte)0x10,
                 (byte)0x01,
             }, result);
     }

     /**
      * Test that writing a with ProtoOutputStream matches, and can be read by standard proto.
      */
     public void testRepeatedCompat() throws Exception {
         testRepeatedCompat(new boolean[0]);
         testRepeatedCompat(new boolean[] { false, true });
     }

     /**
      * Implementation of testRepeatedCompat with a given value.
      */
     public void testRepeatedCompat(boolean[] val) throws Exception {
         final int fieldId = 131;
         final long fieldFlags = ProtoOutputStream.FIELD_COUNT_REPEATED | ProtoOutputStream.FIELD_TYPE_BOOL;

         final Test.All all = new Test.All();
         final ProtoOutputStream po = new ProtoOutputStream(0);

         all.boolFieldRepeated = val;
         for (int i=0; i<val.length; i++) {
             po.writeRepeatedBool(ProtoOutputStream.makeFieldId(fieldId, fieldFlags), val[i]);
         }

         final byte[] result = po.getBytes();
         final byte[] expected = MessageNano.toByteArray(all);

         Assert.assertArrayEquals(expected, result);

         final Test.All readback = Test.All.parseFrom(result);

         assertNotNull(readback.boolFieldRepeated);
         assertEquals(val.length, readback.boolFieldRepeated.length);
         for (int i=0; i<val.length; i++) {
             assertEquals(val[i], readback.boolFieldRepeated[i]);
         }
     }

     // ----------------------------------------------------------------------
     //  writePackedBool
     // ----------------------------------------------------------------------

     /**
      * Test writePackedBool.
      */
     public void testPacked() throws Exception {
         testPacked(0);
         testPacked(1);
         testPacked(5);
     }

     /**
      * Create an array of the val, and write it.
      */
     private void writePackedBool(ProtoOutputStream po, int fieldId, boolean val) {
         final long fieldFlags = ProtoOutputStream.FIELD_COUNT_PACKED | ProtoOutputStream.FIELD_TYPE_BOOL;
         po.writePackedBool(ProtoOutputStream.makeFieldId(fieldId, fieldFlags),
                 new boolean[] { val, val });
     }

     /**
      * Implementation of testPacked with a given chunkSize.
      */
     public void testPacked(int chunkSize) throws Exception {
         final ProtoOutputStream po = new ProtoOutputStream(chunkSize);
         final long fieldFlags = ProtoOutputStream.FIELD_COUNT_PACKED | ProtoOutputStream.FIELD_TYPE_BOOL;

         po.writePackedBool(ProtoOutputStream.makeFieldId(1000, fieldFlags), null);
         po.writePackedBool(ProtoOutputStream.makeFieldId(1001, fieldFlags), new boolean[0]);
         writePackedBool(po, 1, false);
         writePackedBool(po, 2, true);

         final byte[] result = po.getBytes();
         Assert.assertArrayEquals(new byte[] {
                 // 1 -> 0 - default value, written when repeated
                 (byte)0x0a,
                 (byte)0x02,
                 (byte)0x00,
                 (byte)0x00,
                 // 2 -> 1
                 (byte)0x12,
                 (byte)0x02,
                 (byte)0x01,
                 (byte)0x01,
             }, result);
     }

     /**
      * Test that writing a with ProtoOutputStream matches, and can be read by standard proto.
      */
     public void testPackedCompat() throws Exception {
         testPackedCompat(new boolean[] {});
         testPackedCompat(new boolean[] { false, true });
     }

     /**
      * Implementation of testPackedBoolCompat with a given value.
      */
     public void testPackedCompat(boolean[] val) throws Exception {
         final int fieldId = 132;
         final long fieldFlags = ProtoOutputStream.FIELD_COUNT_PACKED | ProtoOutputStream.FIELD_TYPE_BOOL;

         final Test.All all = new Test.All();
         final ProtoOutputStream po = new ProtoOutputStream(0);

         all.boolFieldPacked = val;
         po.writePackedBool(ProtoOutputStream.makeFieldId(fieldId, fieldFlags), val);

         final byte[] result = po.getBytes();
         final byte[] expected = MessageNano.toByteArray(all);

         Assert.assertArrayEquals(expected, result);

         final Test.All readback = Test.All.parseFrom(result);

         Assert.assertArrayEquals(val, readback.boolFieldPacked);
     }

     /**
      * Test that if you pass in the wrong type of fieldId, it throws.
      */
     public void testBadFieldIds() {
         // Single

         // Good Count / Bad Type
         try {
             final ProtoOutputStream po = new ProtoOutputStream();
             po.writeBool(ProtoOutputStream.makeFieldId(1,
                         ProtoOutputStream.FIELD_COUNT_SINGLE | ProtoOutputStream.FIELD_TYPE_DOUBLE), false);
         } catch (IllegalArgumentException ex) {
             // good
         }

         // Bad Count / Good Type
         try {
             final ProtoOutputStream po = new ProtoOutputStream();
             po.writeBool(ProtoOutputStream.makeFieldId(1,
                         ProtoOutputStream.FIELD_COUNT_PACKED | ProtoOutputStream.FIELD_TYPE_BOOL), false);
         } catch (IllegalArgumentException ex) {
             // good
         }

         // Repeated

         // Good Count / Bad Type
         try {
             final ProtoOutputStream po = new ProtoOutputStream();
             po.writeRepeatedBool(ProtoOutputStream.makeFieldId(1,
                         ProtoOutputStream.FIELD_COUNT_REPEATED | ProtoOutputStream.FIELD_TYPE_DOUBLE), false);
         } catch (IllegalArgumentException ex) {
             // good
         }

         // Bad Count / Good Type
         try {
             final ProtoOutputStream po = new ProtoOutputStream();
             po.writeRepeatedBool(ProtoOutputStream.makeFieldId(1,
                         ProtoOutputStream.FIELD_COUNT_PACKED | ProtoOutputStream.FIELD_TYPE_BOOL), false);
         } catch (IllegalArgumentException ex) {
             // good
         }

         // Packed

         // Good Count / Bad Type
         try {
             final ProtoOutputStream po = new ProtoOutputStream();
             po.writePackedBool(ProtoOutputStream.makeFieldId(1,
                         ProtoOutputStream.FIELD_COUNT_PACKED | ProtoOutputStream.FIELD_TYPE_DOUBLE),
                     new boolean[0]);
         } catch (IllegalArgumentException ex) {
             // good
         }

         // Bad Count / Good Type
         try {
             final ProtoOutputStream po = new ProtoOutputStream();
             po.writePackedBool(ProtoOutputStream.makeFieldId(1,
                         ProtoOutputStream.FIELD_COUNT_SINGLE | ProtoOutputStream.FIELD_TYPE_BOOL),
                     new boolean[0]);
         } catch (IllegalArgumentException ex) {
             // good
         }
     }
 }
	/*
	* Copyright (C) 2016 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 android.util.proto.cts;

	import android.util.proto.ProtoOutputStream;
	import android.util.proto.cts.nano.Test;

	import com.google.protobuf.nano.MessageNano;
	import junit.framework.TestCase;
	import org.junit.Assert;

	/**
	* Test the bool methods on the ProtoOutputStream class.
	*/
	public class ProtoOutputStreamBoolTest extends TestCase {

	// ----------------------------------------------------------------------
	// writeBool
	// ----------------------------------------------------------------------

	/**
	* Test writeBool.
	*/
	public void testWrite() throws Exception {
	testWrite(0);
	testWrite(1);
	testWrite(5);
	}

	/**
	* Implementation of testWrite with a given chunkSize.
	*/
	public void testWrite(int chunkSize) throws Exception {
	final ProtoOutputStream po = new ProtoOutputStream(chunkSize);
	final long fieldFlags = ProtoOutputStream.FIELD_COUNT_SINGLE \| ProtoOutputStream.FIELD_TYPE_BOOL;

	po.writeBool(ProtoOutputStream.makeFieldId(1, fieldFlags), false);
	po.writeBool(ProtoOutputStream.makeFieldId(2, fieldFlags), true);

	final byte[] result = po.getBytes();
	Assert.assertArrayEquals(new byte[] {
	// 1 -> 0 - default value, not written
	// 2 -> 1
	(byte)0x10,
	(byte)0x01,
	}, result);
	}

	/**
	* Test that writing a with ProtoOutputStream matches, and can be read by standard proto.
	*/
	public void testWriteCompat() throws Exception {
	testWriteCompat(false);
	testWriteCompat(true);
	}

	/**
	* Implementation of testWriteCompat with a given value.
	*/
	public void testWriteCompat(boolean val) throws Exception {
	final int fieldId = 130;
	final long fieldFlags = ProtoOutputStream.FIELD_COUNT_SINGLE \| ProtoOutputStream.FIELD_TYPE_BOOL;

	final Test.All all = new Test.All();
	final ProtoOutputStream po = new ProtoOutputStream(0);

	all.boolField = val;
	po.writeBool(ProtoOutputStream.makeFieldId(fieldId, fieldFlags), val);

	final byte[] result = po.getBytes();
	final byte[] expected = MessageNano.toByteArray(all);

	Assert.assertArrayEquals(expected, result);

	final Test.All readback = Test.All.parseFrom(result);

	assertEquals(val, readback.boolField);
	}

	// ----------------------------------------------------------------------
	// writeRepeatedBool
	// ----------------------------------------------------------------------

	/**
	* Test writeRepeatedBool.
	*/
	public void testRepeated() throws Exception {
	testRepeated(0);
	testRepeated(1);
	testRepeated(5);
	}

	/**
	* Implementation of testRepeated with a given chunkSize.
	*/
	public void testRepeated(int chunkSize) throws Exception {
	final ProtoOutputStream po = new ProtoOutputStream(chunkSize);
	final long fieldFlags = ProtoOutputStream.FIELD_COUNT_REPEATED \| ProtoOutputStream.FIELD_TYPE_BOOL;

	po.writeRepeatedBool(ProtoOutputStream.makeFieldId(1, fieldFlags), false);
	po.writeRepeatedBool(ProtoOutputStream.makeFieldId(2, fieldFlags), true);

	po.writeRepeatedBool(ProtoOutputStream.makeFieldId(1, fieldFlags), false);
	po.writeRepeatedBool(ProtoOutputStream.makeFieldId(2, fieldFlags), true);

	final byte[] result = po.getBytes();
	Assert.assertArrayEquals(new byte[] {
	// 1 -> 0 - default value, written when repeated
	(byte)0x08,
	(byte)0x00,
	// 2 -> 1
	(byte)0x10,
	(byte)0x01,

	// 1 -> 0 - default value, written when repeated
	(byte)0x08,
	(byte)0x00,
	// 2 -> 1
	(byte)0x10,
	(byte)0x01,
	}, result);
	}

	/**
	* Test that writing a with ProtoOutputStream matches, and can be read by standard proto.
	*/
	public void testRepeatedCompat() throws Exception {
	testRepeatedCompat(new boolean[0]);
	testRepeatedCompat(new boolean[] { false, true });
	}

	/**
	* Implementation of testRepeatedCompat with a given value.
	*/
	public void testRepeatedCompat(boolean[] val) throws Exception {
	final int fieldId = 131;
	final long fieldFlags = ProtoOutputStream.FIELD_COUNT_REPEATED \| ProtoOutputStream.FIELD_TYPE_BOOL;

	final Test.All all = new Test.All();
	final ProtoOutputStream po = new ProtoOutputStream(0);

	all.boolFieldRepeated = val;
	for (int i=0; i<val.length; i++) {
	po.writeRepeatedBool(ProtoOutputStream.makeFieldId(fieldId, fieldFlags), val[i]);
	}

	final byte[] result = po.getBytes();
	final byte[] expected = MessageNano.toByteArray(all);

	Assert.assertArrayEquals(expected, result);

	final Test.All readback = Test.All.parseFrom(result);

	assertNotNull(readback.boolFieldRepeated);
	assertEquals(val.length, readback.boolFieldRepeated.length);
	for (int i=0; i<val.length; i++) {
	assertEquals(val[i], readback.boolFieldRepeated[i]);
	}
	}

	// ----------------------------------------------------------------------
	// writePackedBool
	// ----------------------------------------------------------------------

	/**
	* Test writePackedBool.
	*/
	public void testPacked() throws Exception {
	testPacked(0);
	testPacked(1);
	testPacked(5);
	}

	/**
	* Create an array of the val, and write it.
	*/
	private void writePackedBool(ProtoOutputStream po, int fieldId, boolean val) {
	final long fieldFlags = ProtoOutputStream.FIELD_COUNT_PACKED \| ProtoOutputStream.FIELD_TYPE_BOOL;
	po.writePackedBool(ProtoOutputStream.makeFieldId(fieldId, fieldFlags),
	new boolean[] { val, val });
	}

	/**
	* Implementation of testPacked with a given chunkSize.
	*/
	public void testPacked(int chunkSize) throws Exception {
	final ProtoOutputStream po = new ProtoOutputStream(chunkSize);
	final long fieldFlags = ProtoOutputStream.FIELD_COUNT_PACKED \| ProtoOutputStream.FIELD_TYPE_BOOL;

	po.writePackedBool(ProtoOutputStream.makeFieldId(1000, fieldFlags), null);
	po.writePackedBool(ProtoOutputStream.makeFieldId(1001, fieldFlags), new boolean[0]);
	writePackedBool(po, 1, false);
	writePackedBool(po, 2, true);

	final byte[] result = po.getBytes();
	Assert.assertArrayEquals(new byte[] {
	// 1 -> 0 - default value, written when repeated
	(byte)0x0a,
	(byte)0x02,
	(byte)0x00,
	(byte)0x00,
	// 2 -> 1
	(byte)0x12,
	(byte)0x02,
	(byte)0x01,
	(byte)0x01,
	}, result);
	}

	/**
	* Test that writing a with ProtoOutputStream matches, and can be read by standard proto.
	*/
	public void testPackedCompat() throws Exception {
	testPackedCompat(new boolean[] {});
	testPackedCompat(new boolean[] { false, true });
	}

	/**
	* Implementation of testPackedBoolCompat with a given value.
	*/
	public void testPackedCompat(boolean[] val) throws Exception {
	final int fieldId = 132;
	final long fieldFlags = ProtoOutputStream.FIELD_COUNT_PACKED \| ProtoOutputStream.FIELD_TYPE_BOOL;

	final Test.All all = new Test.All();
	final ProtoOutputStream po = new ProtoOutputStream(0);

	all.boolFieldPacked = val;
	po.writePackedBool(ProtoOutputStream.makeFieldId(fieldId, fieldFlags), val);

	final byte[] result = po.getBytes();
	final byte[] expected = MessageNano.toByteArray(all);

	Assert.assertArrayEquals(expected, result);

	final Test.All readback = Test.All.parseFrom(result);

	Assert.assertArrayEquals(val, readback.boolFieldPacked);
	}

	/**
	* Test that if you pass in the wrong type of fieldId, it throws.
	*/
	public void testBadFieldIds() {
	// Single

	// Good Count / Bad Type
	try {
	final ProtoOutputStream po = new ProtoOutputStream();
	po.writeBool(ProtoOutputStream.makeFieldId(1,
	ProtoOutputStream.FIELD_COUNT_SINGLE \| ProtoOutputStream.FIELD_TYPE_DOUBLE), false);
	} catch (IllegalArgumentException ex) {
	// good
	}

	// Bad Count / Good Type
	try {
	final ProtoOutputStream po = new ProtoOutputStream();
	po.writeBool(ProtoOutputStream.makeFieldId(1,
	ProtoOutputStream.FIELD_COUNT_PACKED \| ProtoOutputStream.FIELD_TYPE_BOOL), false);
	} catch (IllegalArgumentException ex) {
	// good
	}

	// Repeated

	// Good Count / Bad Type
	try {
	final ProtoOutputStream po = new ProtoOutputStream();
	po.writeRepeatedBool(ProtoOutputStream.makeFieldId(1,
	ProtoOutputStream.FIELD_COUNT_REPEATED \| ProtoOutputStream.FIELD_TYPE_DOUBLE), false);
	} catch (IllegalArgumentException ex) {
	// good
	}

	// Bad Count / Good Type
	try {
	final ProtoOutputStream po = new ProtoOutputStream();
	po.writeRepeatedBool(ProtoOutputStream.makeFieldId(1,
	ProtoOutputStream.FIELD_COUNT_PACKED \| ProtoOutputStream.FIELD_TYPE_BOOL), false);
	} catch (IllegalArgumentException ex) {
	// good
	}

	// Packed

	// Good Count / Bad Type
	try {
	final ProtoOutputStream po = new ProtoOutputStream();
	po.writePackedBool(ProtoOutputStream.makeFieldId(1,
	ProtoOutputStream.FIELD_COUNT_PACKED \| ProtoOutputStream.FIELD_TYPE_DOUBLE),
	new boolean[0]);
	} catch (IllegalArgumentException ex) {
	// good
	}

	// Bad Count / Good Type
	try {
	final ProtoOutputStream po = new ProtoOutputStream();
	po.writePackedBool(ProtoOutputStream.makeFieldId(1,
	ProtoOutputStream.FIELD_COUNT_SINGLE \| ProtoOutputStream.FIELD_TYPE_BOOL),
	new boolean[0]);
	} catch (IllegalArgumentException ex) {
	// good
	}
	}
	}