binding-cpp/runtime/src/test/transport/EtchFlexBufferTest.cpp - etch - Git at Google

 /* $Id$
  *
  * Licensed to the Apache Software Foundation (ASF) under one or more
  * contributor license agreements. See the NOTICE file distributed with
  * this work for additional information regarding copyright ownership.
  * The ASF licenses this file to you 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.
  */


 #include <gtest/gtest.h>
 #include "transport/EtchFlexBuffer.h"
 #include "common/EtchError.h"

 TEST(EtchFlexBufferTest, constructorTest) {
   EtchFlexBuffer *buffer = new EtchFlexBuffer();
   EXPECT_TRUE(buffer != NULL);
   EXPECT_TRUE(buffer->getLength() == 0);
   EXPECT_TRUE(buffer->getIndex() == 0);
   EXPECT_TRUE(buffer->getSize() == 32);
   delete buffer;
 }

 TEST(EtchFlexBufferTest, putTest) {
   EtchFlexBuffer *buffer = new EtchFlexBuffer();
   EtchFlexBuffer *buffer2 = new EtchFlexBuffer();
   capu::int8_t key [] = {'a', 'b', 'c'};

   EXPECT_TRUE(buffer->put(NULL, 32) == ETCH_EINVAL);

   EXPECT_TRUE(buffer->put(key, 0) == ETCH_ERANGE);

   EXPECT_TRUE(buffer->put(key, 3) == ETCH_OK);
   EXPECT_TRUE(memcmp(buffer->getBuffer(), "abc", 3) == 0);

   EXPECT_TRUE((buffer2->put(key, 2)) == ETCH_OK);
   EXPECT_TRUE(memcmp(buffer2->getBuffer(), "ab", 2) == 0);

   buffer->setIndex(0);
   EXPECT_TRUE((buffer2->put(*buffer)) == ETCH_OK);
   EXPECT_TRUE(memcmp(buffer2->getBuffer(), "ababc", 5) == 0);

   EXPECT_TRUE((buffer2->put(*buffer, 1)) == ETCH_OK);
   EXPECT_TRUE(memcmp(buffer2->getBuffer(), "ababca", 6) == 0);

   buffer2->setLength(32);
   buffer2->setIndex(31);
   EXPECT_TRUE((buffer2->put(*buffer, 2)) == ETCH_OK);
   EXPECT_TRUE(strncmp((const char *) &buffer2->getBuffer()[32], "b", 1) == 0);

   delete buffer;
   delete buffer2;
 }

 TEST(EtchFlexBufferTest, getTests) {
   EtchFlexBuffer *buffer = new EtchFlexBuffer();
   capu::int8_t key [] = {'a', 'b', 'c'};

   EXPECT_TRUE(buffer->put(NULL, 32) == ETCH_EINVAL);

   EXPECT_TRUE(buffer->put(key, 0) == ETCH_ERANGE);

   //check the length of valid buffer
   EXPECT_TRUE(buffer->getLength() == 0);
   //check the index position after the insert
   EXPECT_TRUE(buffer->getIndex() == 0);
   //check that there is no new valid buffer to read
   EXPECT_TRUE(buffer->getAvailableBytes() == 0);

   EXPECT_TRUE(buffer->put(key, 3) == ETCH_OK);
   EXPECT_TRUE(memcmp(buffer->getBuffer(), "abc", 3) == 0);

   //check the length of valid buffer
   EXPECT_TRUE(buffer->getLength() == 3);
   //check the current size of the buffer
   EXPECT_TRUE(buffer->getSize() == 32);
   //check the index position after the insert
   EXPECT_TRUE(buffer->getIndex() == 3);
   //check that there is no new valid buffer to read
   EXPECT_TRUE(buffer->getAvailableBytes() == 0);

   delete buffer;
 }

 TEST(EtchFlexBufferTest, setIndexTest) {
   EtchFlexBuffer *buffer = new EtchFlexBuffer();
   capu::int8_t key [] = {'a', 'b', 'c'};

   EXPECT_TRUE(buffer->getIndex() == 0);
   EXPECT_TRUE(buffer->setIndex(129) == ETCH_EINVAL);

   EXPECT_TRUE(buffer->setIndex(0) == ETCH_OK);
   EXPECT_TRUE(buffer->put(key, 3) == ETCH_OK);
   EXPECT_TRUE(memcmp(buffer->getBuffer(), "abc", 3) == 0);

   EXPECT_TRUE(buffer->setIndex(1) == ETCH_OK);
   EXPECT_TRUE(buffer->put(key, 3) == ETCH_OK);
   EXPECT_TRUE(memcmp(buffer->getBuffer(), "aabc", 3) == 0);

   delete buffer;
 }

 TEST(EtchFlexBufferTest, resetTest) {
   EtchFlexBuffer *buffer = new EtchFlexBuffer();
   capu::int8_t key [] = {'a', 'b', 'c'};

   EXPECT_TRUE(buffer->getIndex() == 0);
   EXPECT_TRUE(buffer->setIndex(129) == ETCH_EINVAL);

   EXPECT_TRUE(buffer->setIndex(0) == ETCH_OK);
   EXPECT_TRUE(buffer->put(key, 3) == ETCH_OK);
   EXPECT_TRUE(buffer->getIndex() == 3);
   buffer->reset();
   EXPECT_TRUE(buffer->getIndex() == 0);
   EXPECT_TRUE(buffer->getLength() == 0);

   delete buffer;
 }

 TEST(EtchFlexBufferTest, getTest) {
   EtchFlexBuffer *buffer = new EtchFlexBuffer();
   capu::int8_t key [] = {'a', 'b', 'c'};
   capu::int8_t key2 [3];
   buffer->put(key, 3);
   buffer->setIndex(0);
   capu::uint32_t amount = 0;
   //null
   EXPECT_TRUE(buffer->get(NULL, 4, 5, amount) == ETCH_EINVAL);
   EXPECT_TRUE(amount == 0);
   //if the given length is too long just return the available buffer
   EXPECT_TRUE(buffer->get(key2, 0, 5, amount) == ETCH_OK);
   EXPECT_TRUE(amount == 3);

   //check result
   EXPECT_TRUE(memcmp(key, key2, 3) == 0);
   buffer->setIndex(0);
   //just partial read
   EXPECT_TRUE(buffer->get(key2, 0, 1, amount) == ETCH_OK);
   EXPECT_TRUE(amount == 1);
   //check result
   EXPECT_TRUE(key2[0] == key[0]);
   delete buffer;
 }

 TEST(EtchFlexBufferTest, expansionTest) {
   EtchFlexBuffer *buffer = new EtchFlexBuffer();

   EXPECT_TRUE(buffer->put(NULL, 32) == ETCH_EINVAL);

   //Default size of buffer
   EXPECT_TRUE(buffer->getSize() == 32);
   //Try to expand buffer exceeding the maximum limit
   EXPECT_TRUE(buffer->setLength((4 * 1024 * 1024) + 1) == ETCH_ENO_MEMORY);
   //Still in default size because it is not changed yet
   EXPECT_TRUE(buffer->getSize() == 32);
   //Expand buffer
   EXPECT_TRUE(buffer->setLength(1024 * 1024) == ETCH_OK);
   //check the size of buffer
   EXPECT_TRUE(buffer->getSize() == (1024 * 1024));

   //reset and trim
   buffer->reset();
   //After Trim
   EXPECT_TRUE(buffer->getSize() == (16 * 1024));

   delete buffer;
 }

 TEST(EtchFlexBufferTest, putAndgetIntegerTest) {
   EtchFlexBuffer *buffer = new EtchFlexBuffer();
   capu::int8_t key [] = {'a', 'b', 'c'};

   capu::uint32_t value = 5;
   EXPECT_TRUE(buffer->put(NULL, 32) == ETCH_EINVAL);
   //try to read an integer
   EXPECT_TRUE(buffer->getInteger(value) == ETCH_ERANGE);
   EXPECT_TRUE(buffer->putInt(value) == ETCH_OK);
   value = 0;
   //normal read
   buffer->setIndex(0);
   EXPECT_TRUE(buffer->getInteger(value) == ETCH_OK);
   EXPECT_TRUE(value == 5);
   buffer->reset();
   //let assume that there is only 3 byte on flex buffer
   EXPECT_TRUE(buffer->put(key, 3) == ETCH_OK);
   buffer->setIndex(0);
   EXPECT_TRUE(buffer->getInteger(value) == ETCH_ERANGE);

   delete buffer;
 }

 TEST(EtchFlexBufferTest, putAndgetByte) {
   EtchFlexBuffer *buffer = new EtchFlexBuffer();

   capu::int8_t value = 5;
   //try to read an integer
   EXPECT_TRUE(buffer->getByte(value) == ETCH_ERANGE);
   EXPECT_TRUE(buffer->putByte(value) == ETCH_OK);
   value = 0;
   //normal read
   buffer->setIndex(0);
   EXPECT_TRUE(buffer->getByte(value) == ETCH_OK);
   EXPECT_TRUE(value == 5);
   buffer->reset();
   //let assume that there is only 0 byte on flex buffer
   buffer->setIndex(0);
   EXPECT_TRUE(buffer->getByte(value) == ETCH_ERANGE);

   delete buffer;
 }

 TEST(EtchFlexBufferTest, putAndgetShort) {
   EtchFlexBuffer *buffer = new EtchFlexBuffer();
   capu::int8_t key [] = {'a'};

   capu::int16_t value = 5;
   //try to read an integer
   EXPECT_TRUE(buffer->getShort(value) == ETCH_ERANGE);
   EXPECT_TRUE(buffer->putShort(value) == ETCH_OK);
   value = 0;
   //normal read
   buffer->setIndex(0);
   EXPECT_TRUE(buffer->getShort(value) == ETCH_OK);
   EXPECT_TRUE(value == 5);
   buffer->reset();
   //let assume that there is only 1 byte on flex buffer
   EXPECT_TRUE(buffer->put(key, 1) == ETCH_OK);
   buffer->setIndex(0);
   EXPECT_TRUE(buffer->getShort(value) == ETCH_ERANGE);

   delete buffer;
 }

 TEST(EtchFlexBufferTest, putAndgetLong) {
   EtchFlexBuffer *buffer = new EtchFlexBuffer();
   capu::int8_t key [] = {'a', 'b', 'c'};

   capu::int64_t value = 5;
   //try to read an integer
   EXPECT_TRUE(buffer->getLong(value) == ETCH_ERANGE);
   EXPECT_TRUE(buffer->putLong(value) == ETCH_OK);
   value = 0;
   //normal read
   buffer->setIndex(0);
   EXPECT_TRUE(buffer->getLong(value) == ETCH_OK);
   EXPECT_TRUE(value == 5);
   buffer->reset();
   //let assume that there is only 3 byte on flex buffer
   EXPECT_TRUE(buffer->put(key, 3) == ETCH_OK);
   buffer->setIndex(0);
   EXPECT_TRUE(buffer->getLong(value) == ETCH_ERANGE);

   delete buffer;
 }

 TEST(EtchFlexBufferTest, putAndgetFloat) {
   EtchFlexBuffer *buffer = new EtchFlexBuffer();
   capu::int8_t key [] = {'a', 'b', 'c'};

   capu::float_t value = 5.3f;
   //try to read an integer
   EXPECT_TRUE(buffer->getFloat(value) == ETCH_ERANGE);
   EXPECT_TRUE(buffer->putFloat(value) == ETCH_OK);
   value = 0;
   //normal read
   buffer->setIndex(0);
   EXPECT_TRUE(buffer->getFloat(value) == ETCH_OK);
   EXPECT_TRUE(value == 5.3f);
   buffer->reset();
   //let assume that there is only 3 byte on flex buffer
   EXPECT_TRUE(buffer->put(key, 3) == ETCH_OK);
   buffer->setIndex(0);
   EXPECT_TRUE(buffer->getFloat(value) == ETCH_ERANGE);

   delete buffer;
 }

 TEST(EtchFlexBufferTest, putAndgetDouble) {
   EtchFlexBuffer *buffer = new EtchFlexBuffer();
   capu::int8_t key [] = {'a', 'b', 'c'};

   capu::double_t value = 5.2;
   //try to read an integer
   EXPECT_TRUE(buffer->getDouble(value) == ETCH_ERANGE);
   EXPECT_TRUE(buffer->putDouble(value) == ETCH_OK);
   value = 0;
   //normal read
   buffer->setIndex(0);
   EXPECT_TRUE(buffer->getDouble(value) == ETCH_OK);
   EXPECT_TRUE(value == 5.2);
   buffer->reset();
   //let assume that there is only 3 byte on flex buffer
   EXPECT_TRUE(buffer->put(key, 3) == ETCH_OK);
   buffer->setIndex(0);
   EXPECT_TRUE(buffer->getDouble(value) == ETCH_ERANGE);

   delete buffer;
 }
	/* $Id$
	*
	* Licensed to the Apache Software Foundation (ASF) under one or more
	* contributor license agreements. See the NOTICE file distributed with
	* this work for additional information regarding copyright ownership.
	* The ASF licenses this file to you 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.
	*/


	#include <gtest/gtest.h>
	#include "transport/EtchFlexBuffer.h"
	#include "common/EtchError.h"

	TEST(EtchFlexBufferTest, constructorTest) {
	EtchFlexBuffer *buffer = new EtchFlexBuffer();
	EXPECT_TRUE(buffer != NULL);
	EXPECT_TRUE(buffer->getLength() == 0);
	EXPECT_TRUE(buffer->getIndex() == 0);
	EXPECT_TRUE(buffer->getSize() == 32);
	delete buffer;
	}

	TEST(EtchFlexBufferTest, putTest) {
	EtchFlexBuffer *buffer = new EtchFlexBuffer();
	EtchFlexBuffer *buffer2 = new EtchFlexBuffer();
	capu::int8_t key [] = {'a', 'b', 'c'};

	EXPECT_TRUE(buffer->put(NULL, 32) == ETCH_EINVAL);

	EXPECT_TRUE(buffer->put(key, 0) == ETCH_ERANGE);

	EXPECT_TRUE(buffer->put(key, 3) == ETCH_OK);
	EXPECT_TRUE(memcmp(buffer->getBuffer(), "abc", 3) == 0);

	EXPECT_TRUE((buffer2->put(key, 2)) == ETCH_OK);
	EXPECT_TRUE(memcmp(buffer2->getBuffer(), "ab", 2) == 0);

	buffer->setIndex(0);
	EXPECT_TRUE((buffer2->put(*buffer)) == ETCH_OK);
	EXPECT_TRUE(memcmp(buffer2->getBuffer(), "ababc", 5) == 0);

	EXPECT_TRUE((buffer2->put(*buffer, 1)) == ETCH_OK);
	EXPECT_TRUE(memcmp(buffer2->getBuffer(), "ababca", 6) == 0);

	buffer2->setLength(32);
	buffer2->setIndex(31);
	EXPECT_TRUE((buffer2->put(*buffer, 2)) == ETCH_OK);
	EXPECT_TRUE(strncmp((const char *) &buffer2->getBuffer()[32], "b", 1) == 0);

	delete buffer;
	delete buffer2;
	}

	TEST(EtchFlexBufferTest, getTests) {
	EtchFlexBuffer *buffer = new EtchFlexBuffer();
	capu::int8_t key [] = {'a', 'b', 'c'};

	EXPECT_TRUE(buffer->put(NULL, 32) == ETCH_EINVAL);

	EXPECT_TRUE(buffer->put(key, 0) == ETCH_ERANGE);

	//check the length of valid buffer
	EXPECT_TRUE(buffer->getLength() == 0);
	//check the index position after the insert
	EXPECT_TRUE(buffer->getIndex() == 0);
	//check that there is no new valid buffer to read
	EXPECT_TRUE(buffer->getAvailableBytes() == 0);

	EXPECT_TRUE(buffer->put(key, 3) == ETCH_OK);
	EXPECT_TRUE(memcmp(buffer->getBuffer(), "abc", 3) == 0);

	//check the length of valid buffer
	EXPECT_TRUE(buffer->getLength() == 3);
	//check the current size of the buffer
	EXPECT_TRUE(buffer->getSize() == 32);
	//check the index position after the insert
	EXPECT_TRUE(buffer->getIndex() == 3);
	//check that there is no new valid buffer to read
	EXPECT_TRUE(buffer->getAvailableBytes() == 0);

	delete buffer;
	}

	TEST(EtchFlexBufferTest, setIndexTest) {
	EtchFlexBuffer *buffer = new EtchFlexBuffer();
	capu::int8_t key [] = {'a', 'b', 'c'};

	EXPECT_TRUE(buffer->getIndex() == 0);
	EXPECT_TRUE(buffer->setIndex(129) == ETCH_EINVAL);

	EXPECT_TRUE(buffer->setIndex(0) == ETCH_OK);
	EXPECT_TRUE(buffer->put(key, 3) == ETCH_OK);
	EXPECT_TRUE(memcmp(buffer->getBuffer(), "abc", 3) == 0);

	EXPECT_TRUE(buffer->setIndex(1) == ETCH_OK);
	EXPECT_TRUE(buffer->put(key, 3) == ETCH_OK);
	EXPECT_TRUE(memcmp(buffer->getBuffer(), "aabc", 3) == 0);

	delete buffer;
	}

	TEST(EtchFlexBufferTest, resetTest) {
	EtchFlexBuffer *buffer = new EtchFlexBuffer();
	capu::int8_t key [] = {'a', 'b', 'c'};

	EXPECT_TRUE(buffer->getIndex() == 0);
	EXPECT_TRUE(buffer->setIndex(129) == ETCH_EINVAL);

	EXPECT_TRUE(buffer->setIndex(0) == ETCH_OK);
	EXPECT_TRUE(buffer->put(key, 3) == ETCH_OK);
	EXPECT_TRUE(buffer->getIndex() == 3);
	buffer->reset();
	EXPECT_TRUE(buffer->getIndex() == 0);
	EXPECT_TRUE(buffer->getLength() == 0);

	delete buffer;
	}

	TEST(EtchFlexBufferTest, getTest) {
	EtchFlexBuffer *buffer = new EtchFlexBuffer();
	capu::int8_t key [] = {'a', 'b', 'c'};
	capu::int8_t key2 [3];
	buffer->put(key, 3);
	buffer->setIndex(0);
	capu::uint32_t amount = 0;
	//null
	EXPECT_TRUE(buffer->get(NULL, 4, 5, amount) == ETCH_EINVAL);
	EXPECT_TRUE(amount == 0);
	//if the given length is too long just return the available buffer
	EXPECT_TRUE(buffer->get(key2, 0, 5, amount) == ETCH_OK);
	EXPECT_TRUE(amount == 3);

	//check result
	EXPECT_TRUE(memcmp(key, key2, 3) == 0);
	buffer->setIndex(0);
	//just partial read
	EXPECT_TRUE(buffer->get(key2, 0, 1, amount) == ETCH_OK);
	EXPECT_TRUE(amount == 1);
	//check result
	EXPECT_TRUE(key2[0] == key[0]);
	delete buffer;
	}

	TEST(EtchFlexBufferTest, expansionTest) {
	EtchFlexBuffer *buffer = new EtchFlexBuffer();

	EXPECT_TRUE(buffer->put(NULL, 32) == ETCH_EINVAL);

	//Default size of buffer
	EXPECT_TRUE(buffer->getSize() == 32);
	//Try to expand buffer exceeding the maximum limit
	EXPECT_TRUE(buffer->setLength((4 * 1024 * 1024) + 1) == ETCH_ENO_MEMORY);
	//Still in default size because it is not changed yet
	EXPECT_TRUE(buffer->getSize() == 32);
	//Expand buffer
	EXPECT_TRUE(buffer->setLength(1024 * 1024) == ETCH_OK);
	//check the size of buffer
	EXPECT_TRUE(buffer->getSize() == (1024 * 1024));

	//reset and trim
	buffer->reset();
	//After Trim
	EXPECT_TRUE(buffer->getSize() == (16 * 1024));

	delete buffer;
	}

	TEST(EtchFlexBufferTest, putAndgetIntegerTest) {
	EtchFlexBuffer *buffer = new EtchFlexBuffer();
	capu::int8_t key [] = {'a', 'b', 'c'};

	capu::uint32_t value = 5;
	EXPECT_TRUE(buffer->put(NULL, 32) == ETCH_EINVAL);
	//try to read an integer
	EXPECT_TRUE(buffer->getInteger(value) == ETCH_ERANGE);
	EXPECT_TRUE(buffer->putInt(value) == ETCH_OK);
	value = 0;
	//normal read
	buffer->setIndex(0);
	EXPECT_TRUE(buffer->getInteger(value) == ETCH_OK);
	EXPECT_TRUE(value == 5);
	buffer->reset();
	//let assume that there is only 3 byte on flex buffer
	EXPECT_TRUE(buffer->put(key, 3) == ETCH_OK);
	buffer->setIndex(0);
	EXPECT_TRUE(buffer->getInteger(value) == ETCH_ERANGE);

	delete buffer;
	}

	TEST(EtchFlexBufferTest, putAndgetByte) {
	EtchFlexBuffer *buffer = new EtchFlexBuffer();

	capu::int8_t value = 5;
	//try to read an integer
	EXPECT_TRUE(buffer->getByte(value) == ETCH_ERANGE);
	EXPECT_TRUE(buffer->putByte(value) == ETCH_OK);
	value = 0;
	//normal read
	buffer->setIndex(0);
	EXPECT_TRUE(buffer->getByte(value) == ETCH_OK);
	EXPECT_TRUE(value == 5);
	buffer->reset();
	//let assume that there is only 0 byte on flex buffer
	buffer->setIndex(0);
	EXPECT_TRUE(buffer->getByte(value) == ETCH_ERANGE);

	delete buffer;
	}

	TEST(EtchFlexBufferTest, putAndgetShort) {
	EtchFlexBuffer *buffer = new EtchFlexBuffer();
	capu::int8_t key [] = {'a'};

	capu::int16_t value = 5;
	//try to read an integer
	EXPECT_TRUE(buffer->getShort(value) == ETCH_ERANGE);
	EXPECT_TRUE(buffer->putShort(value) == ETCH_OK);
	value = 0;
	//normal read
	buffer->setIndex(0);
	EXPECT_TRUE(buffer->getShort(value) == ETCH_OK);
	EXPECT_TRUE(value == 5);
	buffer->reset();
	//let assume that there is only 1 byte on flex buffer
	EXPECT_TRUE(buffer->put(key, 1) == ETCH_OK);
	buffer->setIndex(0);
	EXPECT_TRUE(buffer->getShort(value) == ETCH_ERANGE);

	delete buffer;
	}

	TEST(EtchFlexBufferTest, putAndgetLong) {
	EtchFlexBuffer *buffer = new EtchFlexBuffer();
	capu::int8_t key [] = {'a', 'b', 'c'};

	capu::int64_t value = 5;
	//try to read an integer
	EXPECT_TRUE(buffer->getLong(value) == ETCH_ERANGE);
	EXPECT_TRUE(buffer->putLong(value) == ETCH_OK);
	value = 0;
	//normal read
	buffer->setIndex(0);
	EXPECT_TRUE(buffer->getLong(value) == ETCH_OK);
	EXPECT_TRUE(value == 5);
	buffer->reset();
	//let assume that there is only 3 byte on flex buffer
	EXPECT_TRUE(buffer->put(key, 3) == ETCH_OK);
	buffer->setIndex(0);
	EXPECT_TRUE(buffer->getLong(value) == ETCH_ERANGE);

	delete buffer;
	}

	TEST(EtchFlexBufferTest, putAndgetFloat) {
	EtchFlexBuffer *buffer = new EtchFlexBuffer();
	capu::int8_t key [] = {'a', 'b', 'c'};

	capu::float_t value = 5.3f;
	//try to read an integer
	EXPECT_TRUE(buffer->getFloat(value) == ETCH_ERANGE);
	EXPECT_TRUE(buffer->putFloat(value) == ETCH_OK);
	value = 0;
	//normal read
	buffer->setIndex(0);
	EXPECT_TRUE(buffer->getFloat(value) == ETCH_OK);
	EXPECT_TRUE(value == 5.3f);
	buffer->reset();
	//let assume that there is only 3 byte on flex buffer
	EXPECT_TRUE(buffer->put(key, 3) == ETCH_OK);
	buffer->setIndex(0);
	EXPECT_TRUE(buffer->getFloat(value) == ETCH_ERANGE);

	delete buffer;
	}

	TEST(EtchFlexBufferTest, putAndgetDouble) {
	EtchFlexBuffer *buffer = new EtchFlexBuffer();
	capu::int8_t key [] = {'a', 'b', 'c'};

	capu::double_t value = 5.2;
	//try to read an integer
	EXPECT_TRUE(buffer->getDouble(value) == ETCH_ERANGE);
	EXPECT_TRUE(buffer->putDouble(value) == ETCH_OK);
	value = 0;
	//normal read
	buffer->setIndex(0);
	EXPECT_TRUE(buffer->getDouble(value) == ETCH_OK);
	EXPECT_TRUE(value == 5.2);
	buffer->reset();
	//let assume that there is only 3 byte on flex buffer
	EXPECT_TRUE(buffer->put(key, 3) == ETCH_OK);
	buffer->setIndex(0);
	EXPECT_TRUE(buffer->getDouble(value) == ETCH_ERANGE);

	delete buffer;
	}