├── CMakeLists.txt
├── tests
    ├── CMakeLists.txt.in
    ├── CMakeLists.txt
    ├── simple_int_test.cpp
    ├── iterator_test.cpp
    └── member_func_test.cpp
├── samples
    ├── CMakeLists.txt
    ├── sample_int_buffer.cpp
    ├── sample_custom_buffer.cpp
    └── sample_string_buffer.cpp
├── conanfile.py
├── LICENSE
├── README.md
├── .github
    └── workflows
    │   └── circularbuffer_build_pipeline.yml
└── circular_buffer.h


/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.13)
 2 | 
 3 | 
 4 | cmake_policy(SET CMP0079 NEW)
 5 | project("circularbuffer")
 6 | 
 7 | set(CMAKE_CXX_STANDARD 11)
 8 | set(CMAKE_CXX_STANDARD_REQUIRED ON)
 9 | 
10 | 
11 | add_library(${PROJECT_NAME} INTERFACE)
12 | 
13 | target_include_directories(${PROJECT_NAME} INTERFACE ${${PROJECT_NAME}_SOURCE_DIR})
14 | enable_testing()
15 | add_subdirectory(samples)
16 | add_subdirectory(tests)
17 | 
18 | 
19 | install(TARGETS circularbuffer DESTINATION lib)
20 | 


--------------------------------------------------------------------------------
/tests/CMakeLists.txt.in:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.13)
 2 | 
 3 | project(googletest-download NONE)
 4 | 
 5 | include(ExternalProject)
 6 | ExternalProject_Add(googletest
 7 | 					GIT_REPOSITORY    https://github.com/google/googletest.git
 8 |     				GIT_TAG           release-1.8.0
 9 | 	  				SOURCE_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-src"
10 | 	    			BINARY_DIR        "${CMAKE_CURRENT_BINARY_DIR}/googletest-build"
11 | 		  			CONFIGURE_COMMAND ""
12 | 		    		BUILD_COMMAND     ""
13 | 			  		INSTALL_COMMAND   ""
14 | 			    	TEST_COMMAND      ""
15 | 					)
16 | 


--------------------------------------------------------------------------------
/samples/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | set(CMAKE_CXX_STANDARD 11)
 2 | set(CMAKE_CXX_STANDARD_REQUIRED ON)
 3 | 
 4 | add_executable(sample_int_buffer sample_int_buffer.cpp)
 5 | target_link_libraries(sample_int_buffer
 6 | 					  PRIVATE
 7 | 					  circularbuffer
 8 | 					  )
 9 | 
10 | add_executable(sample_string_buffer sample_string_buffer.cpp)
11 | target_link_libraries(sample_string_buffer
12 | 					  PRIVATE
13 | 					  circularbuffer
14 | 					  )
15 | 
16 | add_executable(sample_custom_buffer sample_custom_buffer.cpp)
17 | target_link_libraries(sample_custom_buffer
18 | 					  PRIVATE
19 | 					  circularbuffer
20 | 					  )
21 | 


--------------------------------------------------------------------------------
/conanfile.py:
--------------------------------------------------------------------------------
 1 | from conans import ConanFile, CMake
 2 | 
 3 | 
 4 | class CircularBufferConan(ConanFile):
 5 |     name = "circular_buffer"
 6 |     version = "0.1.0"
 7 |     license = "MIT License"
 8 |     author = "vinit james  vinit.james24@gmail.com"
 9 |     url = "https://github.com/vinitjames/circularbuffer"
10 |     description = "A simple, general purpose STL style circularbuffer implementation in C++."
11 |     topics = ("circularbuffer", "ringbuffer", "conan-recipe", "c++")
12 |     exports_sources = "*"
13 | 
14 |     def build(self): # this is not building a library, just tests
15 |         cmake = CMake(self)
16 |         cmake.configure()
17 |         cmake.build()
18 |         cmake.test()
19 |     
20 |     def package(self):
21 |         print(self.name)
22 |         self.copy("{}.h".format(self.name), dst="include", src=".")
23 |         self.copy("LICENSE", dst="license", src=".")
24 | 
25 |     def package_info(self):
26 |         self.info.header_only()
27 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
 1 | MIT License
 2 | 
 3 | Copyright (c) 2020 Vinit James
 4 | 
 5 | Permission is hereby granted, free of charge, to any person obtaining a copy
 6 | of this software and associated documentation files (the "Software"), to deal
 7 | in the Software without restriction, including without limitation the rights
 8 | to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
 9 | copies of the Software, and to permit persons to whom the Software is
10 | furnished to do so, subject to the following conditions:
11 | 
12 | The above copyright notice and this permission notice shall be included in all
13 | copies or substantial portions of the Software.
14 | 
15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 | IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 | FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
18 | AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 | LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
20 | OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
21 | SOFTWARE.
22 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | CircularBuffer
 2 | ===========
 3 | 
 4 | [![Actions Status](https://github.com/vinitjames/circularbuffer_CPP/workflows/Build%20and%20Test/badge.svg)](https://github.com/vinitjames/circularbuffer_CPP/actions)   [![MIT License](https://img.shields.io/github/license/vinitjames/circularbuffer?color=blue)](https://github.com/vinitjames/circularbuffer/blob/master/LICENSE)
 5 | ## About
 6 | circularbuffer_CPP is a simple, general purpose STL style [circularbuffer](https://en.wikipedia.org/wiki/Circular_buffer) implementation in C++.
 7 | 
 8 | 
 9 | ## Features
10 | * STL style implementaion of Circular Buffer
11 | * Lightweight (only single header file)
12 | * Simple API conforming to STL container semantics.
13 | * Random Access Iterator for easy forwad and reverse iteration and looping through elements.
14 | * Test suites
15 | 
16 | ## Installation
17 | Run:
18 | ```
19 | git clone https://github.com/vinitjames/circularbuffer_CPP.git
20 | ```
21 | ## Without CMAKE 
22 | copy circular_buffer.h to your project
23 | 
24 | ## With CMAKE 
25 | To locally build and run test run the following commands 
26 | ```sh
27 | $ mkdir build
28 | $ cd build 
29 | $ cmake ..
30 | $ cmake --build .
31 | $ ctest 
32 | ``` 
33 | To include in project as a submodule just clone the repo in a subdirectory and use `add_subdirectory()` in the top level `CMakeLists.txt` 
34 | 


--------------------------------------------------------------------------------
/tests/CMakeLists.txt:
--------------------------------------------------------------------------------
 1 | cmake_minimum_required(VERSION 3.13)
 2 | 
 3 | set(CMAKE_CXX_STANDARD 11)
 4 | set(CMAKE_CXX_STANDARD_REQUIRED ON)
 5 | 
 6 | message(STATUS "cmake in tests, project name ${PROJECT_NAME}" )
 7 | 
 8 | configure_file(CMakeLists.txt.in googletest-download/CMakeLists.txt)
 9 | execute_process(COMMAND ${CMAKE_COMMAND} -G "${CMAKE_GENERATOR}" .
10 | 			    RESULT_VARIABLE result
11 |     			WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download
12 | 				)
13 | if(result)
14 | 	message(FATAL_ERROR "CMake step for googletest failed: ${result}")
15 | endif()
16 | 
17 | execute_process(COMMAND ${CMAKE_COMMAND} --build .
18 | 			    RESULT_VARIABLE result
19 | 		  		WORKING_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}/googletest-download
20 | 				)
21 | 				
22 | if(result)
23 | 	message(FATAL_ERROR "Build step for googletest failed: ${result}")
24 | endif()
25 | 
26 | # Prevent overriding the parent project's compiler/linker
27 | # settings on Windows
28 | set(gtest_force_shared_crt ON CACHE BOOL "" FORCE)
29 | 
30 | # Add googletest directly to our build. This defines
31 | # the gtest and gtest_main targets.
32 | add_subdirectory(${CMAKE_CURRENT_BINARY_DIR}/googletest-src
33 |                  ${CMAKE_CURRENT_BINARY_DIR}/googletest-build
34 | 				 EXCLUDE_FROM_ALL)
35 | 				 
36 | add_executable(simple_int_test simple_int_test.cpp)
37 | target_link_libraries(simple_int_test
38 | 					  circularbuffer
39 | 					  gtest_main
40 | 					  )
41 | add_test(NAME simple_int_test COMMAND simple_int_test)
42 | 
43 | add_executable(member_func_test member_func_test.cpp)
44 | target_link_libraries(member_func_test
45 | 					  circularbuffer
46 | 					  gtest_main
47 | 					  )
48 | add_test(NAME member_func_test COMMAND member_func_test)
49 | 
50 | add_executable(iterator_test iterator_test.cpp)
51 | target_link_libraries(iterator_test
52 | 					  circularbuffer
53 | 					  gtest_main
54 | 					  )
55 | add_test(NAME iterator_test COMMAND iterator_test)
56 | 


--------------------------------------------------------------------------------
/samples/sample_int_buffer.cpp:
--------------------------------------------------------------------------------
 1 | #include "circular_buffer.h"
 2 | #include <iostream>
 3 | #include <string.h>
 4 | 
 5 | int main(int argc, char *argv[])
 6 | {   
 7 | 	//Initializing a buffer
 8 |     CircularBuffer<int> int_buff{5};
 9 | 
10 | 	//checking buffer empty function
11 |     std::cout<<"Calling buffer empty function "<<int_buff.empty()<<"\n";
12 | 	
13 | 	//Pushing data back into buffer
14 | 	std::cout<<"Pushing back  data in bufffer \n";
15 | 	int_buff.push_back(5);
16 | 	int_buff.push_back(2);
17 | 	int_buff.push_back(1250);
18 | 	int_buff.push_back(500);
19 | 	int_buff.push_back(235);
20 | 
21 | 	//Length of buffer
22 | 	std::cout<<"Checking length of buffer "<<int_buff.size()<<"\n";
23 | 	//Using Front Function, gives the first element
24 | 	std::cout<<"Checking front function  "<<int_buff.front()<<"\n";
25 | 	//Using Back Function, gives last element 
26 | 	std::cout<<"Checking back function  "<<int_buff.back()<<"\n";
27 | 	//Front and Back can be used for assignment
28 | 	int_buff.front() = 100;
29 | 	int_buff.back() = 10;
30 | 
31 | 	//Pop Function removes  element as per FIFO
32 | 	std::cout<<"Checking pop_front function\n";
33 | 	int_buff.pop_front();
34 | 	std::cout<<"pop front executed new size: "<<int_buff.size()
35 | 			 <<" new front:" <<int_buff.front()<<"\n";
36 | 	
37 | 	std::cout<<"Checking iterator function\n";
38 | 	auto it = int_buff.begin();
39 | 	
40 | 	std::cout<<"Checking deference * operator "<<*it<<"\n";
41 | 	std::cout<<"Checking deference ++ operator "<<*(++it)<<"\n";
42 | 	std::cout<<"Checking deference -- operator "<<*(--it)<<"\n";
43 | 
44 | 	// Range based  for loop can be used like other STL containers
45 | 	std::cout<<"Checking iterator for loop  \n";
46 | 	for(const auto& it: int_buff)
47 | 		std::cout<<"Checking range based for loop function  "<<it<<"\n";
48 | 
49 | 	// for loop with iterators can be used like other STL stile containers
50 | 	std::cout<<"Checking for loop with iterator  \n";
51 | 	for(auto it = int_buff.begin(); it != int_buff.end(); it++)
52 | 		std::cout<<"Checking for loop function  "<<*it<<"\n";
53 |    
54 | 	return 0;
55 | }
56 | 
57 | 
58 | 
59 | 


--------------------------------------------------------------------------------
/samples/sample_custom_buffer.cpp:
--------------------------------------------------------------------------------
 1 | #include "circular_buffer.h"
 2 | #include <iostream>
 3 | #include <string.h>
 4 | #include <vector>
 5 | #include <thread>
 6 | #include <chrono>
 7 | 
 8 | struct custom_struct{
 9 | 	static int count ; 
10 | 	char* bytes =nullptr;
11 | 	int id = 0;
12 | 	custom_struct(){
13 | 		bytes = (char*)malloc(100);
14 | 		id = count;
15 | 		std::cout<<"constructing custom_struct: "<<count++<<"\n";
16 | 	}
17 | 	
18 | 	custom_struct(const custom_struct& other){
19 | 		bytes = (char*)malloc(100);
20 | 		memcpy(bytes, other.bytes,100);
21 | 		std::cout<<"copy constructor called for custom_struct \n";
22 | 	}
23 | 
24 | 	custom_struct(custom_struct&& other){
25 | 		bytes = other.bytes;
26 | 		other.bytes = nullptr;
27 | 		std::cout<<"move constructor called for custom_struct \n";
28 | 	}
29 | 	
30 | 	custom_struct& operator=(const custom_struct& other){
31 | 		memcpy(bytes, other.bytes,100);
32 | 		std::cout<<"assignment operator called for custom_struct \n";
33 | 		return *this;
34 | 	}
35 | 
36 | 	custom_struct& operator=(custom_struct&& other){
37 | 		delete(bytes);
38 | 		bytes = other.bytes;
39 | 		other.bytes = nullptr;
40 | 		std::cout<<"move assignment operator called for custom_struct \n";
41 | 		return *this;
42 | 	}
43 | 	
44 | 	~custom_struct(){
45 | 		std::cout<<"destructor called for test struct "<<id<<std::endl;
46 | 		count--;
47 | 		free(bytes);
48 | 		bytes = nullptr;
49 | 	}
50 | 
51 | 	friend std::ostream& operator<<(std::ostream& os, const custom_struct& ts){
52 | 		return os<<"Printing struct no: "<< ts.id<<"\n";
53 | 	}
54 | 	
55 | 
56 | };
57 | 
58 | int custom_struct::count =0;
59 | 
60 | 
61 | int main(int argc, char *argv[])
62 | {   
63 | 	CircularBuffer<custom_struct> custom_buffer(5);
64 | 	custom_struct element;
65 | 	for (int i = 0; i < 10; ++i) {
66 | 		custom_buffer.push_back(element);		
67 | 	}
68 | 
69 | 	CircularBuffer<custom_struct> buffermoved = std::move(custom_buffer);
70 | 	CircularBuffer<custom_struct> buffermoveassigned{10};
71 | 	buffermoveassigned = std::move(buffermoved);
72 | 	buffermoveassigned.push_back(std::move(element));
73 | 	return 0;
74 | }
75 | 
76 | 


--------------------------------------------------------------------------------
/.github/workflows/circularbuffer_build_pipeline.yml:
--------------------------------------------------------------------------------
 1 | name: Build and Test
 2 | 
 3 | on: [push, pull_request]
 4 | 
 5 | env:
 6 |   # Customize the CMake build type here (Release, Debug, RelWithDebInfo, etc.)
 7 |   BUILD_TYPE: Release
 8 | 
 9 | jobs:
10 |   build:
11 |     # The CMake configure and build commands are platform agnostic and should work equally
12 |     # well on Windows or Mac.  You can convert this to a matrix build if you need
13 |     # cross-platform coverage.
14 |     # See: https://docs.github.com/en/free-pro-team@latest/actions/learn-github-actions/managing-complex-workflows#using-a-build-matrix
15 |     runs-on: ubuntu-latest
16 | 
17 |     steps:
18 |     - uses: actions/checkout@v2
19 | 
20 |     - name: Create Build Environment
21 |       # Some projects don't allow in-source building, so create a separate build directory
22 |       # We'll use this as our working directory for all subsequent commands
23 |       run: cmake -E make_directory ${{github.workspace}}/build
24 | 
25 |     - name: Configure CMake
26 |       # Use a bash shell so we can use the same syntax for environment variable
27 |       # access regardless of the host operating system
28 |       shell: bash
29 |       working-directory: ${{github.workspace}}/build
30 |       # Note the current convention is to use the -S and -B options here to specify source 
31 |       # and build directories, but this is only available with CMake 3.13 and higher.  
32 |       # The CMake binaries on the Github Actions machines are (as of this writing) 3.12
33 |       run: cmake $GITHUB_WORKSPACE -DCMAKE_BUILD_TYPE=$BUILD_TYPE
34 | 
35 |     - name: Build
36 |       working-directory: ${{github.workspace}}/build
37 |       shell: bash
38 |       # Execute the build.  You can specify a specific target with "--target <NAME>"
39 |       run: cmake --build . --config $BUILD_TYPE
40 | 
41 |     - name: Test
42 |       working-directory: ${{github.workspace}}/build
43 |       shell: bash
44 |       # Execute tests defined by the CMake configuration.  
45 |       # See https://cmake.org/cmake/help/latest/manual/ctest.1.html for more detail
46 |       run: ctest -C $BUILD_TYPE
47 | 


--------------------------------------------------------------------------------
/tests/simple_int_test.cpp:
--------------------------------------------------------------------------------
 1 | #include "circular_buffer.h"
 2 | #include <iostream>
 3 | #include <string.h>
 4 | #include "gtest/gtest.h"
 5 | 
 6 | #define TEST_BUFFER_SIZE 100
 7 | 
 8 | class CircularBufferTest : public ::testing::Test{
 9 | 	
10 | protected:
11 | 	
12 | 	CircularBuffer<int> test{TEST_BUFFER_SIZE};
13 | 	
14 | };
15 | 
16 | TEST_F(CircularBufferTest, CapacityTest){
17 | 	EXPECT_EQ(TEST_BUFFER_SIZE, test.capacity());
18 | 	EXPECT_FALSE(test.capacity() == 0);
19 | }
20 | 
21 | TEST_F(CircularBufferTest, EmptyTest){
22 | 	EXPECT_TRUE(test.empty());
23 | 	test.push_back(10);
24 | 	test.push_back(5);
25 | 	EXPECT_FALSE(test.empty());
26 | 	test.pop_front();
27 | 	test.pop_front();
28 | 	EXPECT_TRUE(test.empty());
29 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
30 | 		test.push_back(10);
31 | 	EXPECT_FALSE(test.empty());
32 | 	
33 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
34 | 		test.pop_front();
35 | 	EXPECT_TRUE(test.empty());
36 | }
37 | 
38 | TEST_F(CircularBufferTest, PushBackTest){
39 | 	EXPECT_TRUE(test.empty());
40 | 	test.push_back(1);
41 | 	test.push_back(2);
42 | 	EXPECT_EQ(1, test.front());
43 | 	EXPECT_EQ(2, test.back());
44 | 	test.pop_front();
45 | 	EXPECT_EQ(2, test.front());
46 | 	EXPECT_EQ(2, test.front());
47 | 	
48 | }
49 | 
50 | TEST_F(CircularBufferTest, PopFrontTest){
51 | 	EXPECT_TRUE(test.empty());
52 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
53 | 		test.push_back(10);
54 | 	EXPECT_TRUE(test.full());
55 | 	while(true){
56 | 		try{
57 | 			test.pop_front();
58 | 		}
59 | 		catch(std::exception& e){
60 | 			EXPECT_TRUE(test.empty());
61 | 			break;
62 | 		}
63 | 	}
64 | 		
65 | }
66 | 
67 | TEST_F(CircularBufferTest, SizeTest){
68 | 	EXPECT_EQ(0, test.size());
69 | 	test.push_back(1);
70 | 	test.push_back(2);
71 | 	EXPECT_EQ(2, test.size());
72 | 	while(!test.full())
73 | 		test.push_back(1);
74 | 	EXPECT_EQ(test.size(), test.capacity());	
75 | }
76 | 
77 | TEST_F(CircularBufferTest, PushAndPopTest){
78 | 	EXPECT_EQ(0, test.size());
79 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
80 | 		test.push_back(i);
81 | 	EXPECT_EQ(TEST_BUFFER_SIZE, test.size());
82 | 	EXPECT_EQ(test.size(), test.capacity());
83 | 
84 | 	for(int i=0; i<TEST_BUFFER_SIZE - 1; i++)
85 | 		test.pop_front();	
86 | 	EXPECT_EQ(1, test.size());
87 | 	EXPECT_EQ(TEST_BUFFER_SIZE, test.capacity());
88 | 	EXPECT_EQ(test.back(), test.front());
89 | 	EXPECT_EQ(TEST_BUFFER_SIZE - 1, test.front());
90 | 	
91 | }
92 | 
93 | 
94 | 
95 | 


--------------------------------------------------------------------------------
/samples/sample_string_buffer.cpp:
--------------------------------------------------------------------------------
 1 | #include "circular_buffer.h"
 2 | #include <iostream>
 3 | #include <string.h>
 4 | #include "circular_buffer.h"
 5 | #include <iostream>
 6 | #include <string.h>
 7 | #include <utility>
 8 | 
 9 | 
10 | int main(int argc, char *argv[])
11 | {   
12 | 	   
13 | 	CircularBuffer<std::string> string_buff{10};
14 | 	//checking buffer empty function
15 |     std::cout<<"Calling buffer empty function "<<string_buff.empty()<<"\n";
16 | 	
17 | 	//Pushing data back into buffer
18 | 	std::cout<<"Pushing back string data in bufffer \n";
19 | 	for(int i = 0; i<10;i++){
20 | 		string_buff.push_back(" sample string " + std::to_string(i));
21 | 		std::cout<<"Pushing back string "<<i<<std::endl;
22 | 	}
23 | 	
24 | 	//Length of buffer
25 | 	std::cout<<"Checking length of buffer "<<string_buff.size()<<"\n";
26 | 	//Using Front Function, gives the first element
27 | 	std::cout<<"Checking front function  "<<string_buff.front()<<"\n";
28 | 	//Using Back Function, gives last element 
29 | 	std::cout<<"Checking back function  "<<string_buff.back()<<"\n";
30 | 	//Front and Back can be used for assignment
31 | 	string_buff.front() = "modified front string";
32 | 	string_buff.back() = "modified back string";
33 | 
34 | 	//Pop Function removes  element as per FIFO
35 | 	std::cout<<"Checking pop_front function\n";
36 | 	string_buff.pop_front();
37 | 	std::cout<<"pop front executed new size: "<<string_buff.size()
38 | 			 <<" new front:" <<string_buff.front()<<"\n";
39 | 	
40 | 	std::cout<<"Checking iterator function\n";
41 | 	auto it = string_buff.begin();
42 | 	
43 | 	std::cout<<"Checking deference * operator "<<*it<<"\n";
44 | 	std::cout<<"Checking deference ++ operator "<<*(++it)<<"\n";
45 | 	std::cout<<"Checking deference -- operator "<<*(--it)<<"\n";
46 | 
47 | 	// Range based  for loop can be used like other STL containers
48 | 	std::cout<<"Checking iterator for loop  \n";
49 | 	for(auto& it: string_buff)
50 | 		std::cout<<"Checking range based for loop function  "<<it<<"\n";
51 | 
52 | 	// for loop with iterators can be used like other STL stile containers
53 | 	std::cout<<"Checking for loop with iterator  \n";
54 | 	for(auto it = string_buff.begin(); it != string_buff.end(); it++)
55 | 		std::cout<<"Checking for loop function  "<<*it<<"\n";
56 |    
57 | 	// push_back using move semantics
58 | 	std::string string_to_move{"This string is moved"};
59 | 	string_buff.push_back(std::move(string_to_move));
60 | 	std::cout<<"string moved to buffer  new size: "<<string_buff.size()
61 | 			 <<" new back:" <<string_buff.back()<<"\n";
62 | 
63 | 	//creating buffer from another buffer
64 | 	CircularBuffer<std::string> string_buff_copy1{string_buff};
65 | 	std::cout<<"Buffer Copy Created, copied buffer size "<<string_buff_copy1.size()<<"\n";
66 | 
67 | 	//copying buffer 
68 | 	CircularBuffer<std::string> string_buff_copy2{10};
69 | 	string_buff_copy2 = string_buff;
70 | 	std::cout<<"Buffer Copy assigned , copied buffer size "<<string_buff_copy2.size()<<"\n";
71 | 	
72 | 	//move constructing
73 | 	CircularBuffer<std::string> string_buff_move1{std::move(string_buff)};
74 | 	std::cout<<"Buffer created with move constructor, moved buffer size "<<string_buff_move1.size()<<"\n";
75 | 
76 | 	//move assignment 
77 | 	CircularBuffer<std::string> string_buff_move2{10};
78 | 	string_buff_move2 = std::move(string_buff_move1);
79 | 	std::cout<<"Buffer  moved with  assignment operator, moved buffer size "<<string_buff_move2.size()<<"\n";
80 | 	
81 | }
82 | 


--------------------------------------------------------------------------------
/tests/iterator_test.cpp:
--------------------------------------------------------------------------------
  1 | #include "circular_buffer.h"
  2 | #include <algorithm>
  3 | #include <string>
  4 | #include <utility>
  5 | #include "gtest/gtest.h"
  6 | 
  7 | #define TEST_BUFFER_SIZE 100
  8 | #define REDUCE_SIZE 50
  9 | 
 10 | class CircularBufferTest : public ::testing::Test{
 11 | 	
 12 | protected:
 13 | 	
 14 | 	CircularBuffer<std::string> test_str_buff{TEST_BUFFER_SIZE};
 15 | 	CircularBuffer<int> test_int_buff{TEST_BUFFER_SIZE};
 16 | };
 17 | 
 18 | TEST_F(CircularBufferTest, IteratorBasedLoopTest){	
 19 | 	//create full buffer
 20 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
 21 | 		test_str_buff.push_back("string" + std::to_string(i));
 22 |     int i = 0;
 23 | 	for(auto it = test_str_buff.begin(); it!=test_str_buff.end(); it++)
 24 | 		EXPECT_EQ(*it, "string" + std::to_string(i++));
 25 | 	//partially fill buffers
 26 | 	test_str_buff.clear();
 27 | 	for(int i=0; i<TEST_BUFFER_SIZE/2; i++)
 28 | 		test_str_buff.push_back("string" + std::to_string(i));
 29 | 	//test begin and end on partially full buffer
 30 | 	i = 0;
 31 | 	for(auto it = test_str_buff.begin(); it!=test_str_buff.end(); it++)
 32 | 		EXPECT_EQ(*it, "string" + std::to_string(i++));
 33 | 	//test size with increment variable
 34 | 	EXPECT_EQ(i, TEST_BUFFER_SIZE/2);
 35 | }
 36 | 
 37 | TEST_F(CircularBufferTest, ReverseIteratorBasedLoopTest){	
 38 | 	//create full buffer
 39 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
 40 | 		test_str_buff.push_back("string" + std::to_string(i));
 41 |     int i = 99;
 42 | 	for(auto it = test_str_buff.rbegin(); it!=test_str_buff.rend(); it++)
 43 | 		EXPECT_EQ(*it, "string" + std::to_string(i--));
 44 | 	//partially fill buffers
 45 | 	test_str_buff.clear();
 46 | 	for(int i=0; i<TEST_BUFFER_SIZE/2; i++)
 47 | 		test_str_buff.push_back("string" + std::to_string(i));
 48 | 	//test begin and end on partially full buffer
 49 | 	i = TEST_BUFFER_SIZE/2 - 1;
 50 | 	for(auto it = test_str_buff.rbegin(); it!=test_str_buff.rend(); it++)
 51 | 		EXPECT_EQ(*it, "string" + std::to_string(i--));
 52 | }
 53 | 
 54 | TEST_F(CircularBufferTest, RangeBasedLoopTest){	
 55 | 	//create full buffer
 56 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
 57 | 		test_str_buff.push_back("string" + std::to_string(i));
 58 | 	int i = 0;
 59 | 	//copied elements 
 60 |     for(auto buff_elem : test_str_buff)
 61 | 		EXPECT_EQ(buff_elem, "string" + std::to_string(i++));
 62 | 	//auto reference
 63 | 	i = 0;
 64 |     for(auto& buff_elem : test_str_buff)
 65 | 		EXPECT_EQ(buff_elem, "string" + std::to_string(i++));	
 66 | 	//auto const reference
 67 | 	i = 0;
 68 |     for(const auto& buff_elem : test_str_buff)
 69 | 		EXPECT_EQ(buff_elem, "string" + std::to_string(i++));
 70 | 	//check iterators after modifications
 71 | 	for(int i = 0; i<REDUCE_SIZE; i++)
 72 | 		test_str_buff.pop_front();
 73 | 	i = TEST_BUFFER_SIZE - REDUCE_SIZE;
 74 |     for(const auto& buff_elem : test_str_buff)
 75 | 		EXPECT_EQ(buff_elem, "string" + std::to_string(i++));
 76 | }
 77 | 
 78 | TEST_F(CircularBufferTest, FindTest){	
 79 | 	//create full buffer
 80 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
 81 | 		test_str_buff.push_back("string" + std::to_string(i));
 82 | 	auto result = std::find(test_str_buff.cbegin(), test_str_buff.cend(), "string50");
 83 | 	EXPECT_EQ(*result, "string50");
 84 | 	result  = std::find(test_str_buff.cbegin(), test_str_buff.cend(), "string100");
 85 | 	EXPECT_EQ(result, test_str_buff.cend());
 86 | 	//partial buffer search
 87 | 	result  = std::find(test_str_buff.cbegin(), test_str_buff.cbegin() + 50, "string30");
 88 | 	EXPECT_EQ(*result, "string30");
 89 | 	result  = std::find(test_str_buff.cbegin(), test_str_buff.cbegin() + 50, "string51");
 90 | 	EXPECT_EQ(result, test_str_buff.cbegin() + 50);
 91 | }
 92 | 
 93 | TEST_F(CircularBufferTest, ForEachTest){	
 94 | 	//create full buffer
 95 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
 96 | 		test_str_buff.push_back("string" + std::to_string(i));
 97 | 	std::for_each(test_str_buff.begin(), test_str_buff.end(), [](std::string& elem){
 98 | 		elem = elem + "modified";});
 99 | 	int i=0;
100 | 	for(const auto& elem: test_str_buff)
101 | 		EXPECT_EQ(elem, "string" + std::to_string(i++) + "modified");	
102 | }
103 | 
104 | TEST_F(CircularBufferTest, SortTest){	
105 | 	//create full buffer
106 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
107 | 		test_int_buff.push_back(i);
108 | 	std::sort(test_int_buff.begin(), test_int_buff.end(), std::greater<int>());
109 | 	int i = 99;
110 | 	for(const auto& elem: test_int_buff)
111 | 		EXPECT_EQ(elem, i--);
112 | }
113 | 
114 | TEST_F(CircularBufferTest, CopyUsingIterator){	
115 | 	//create full buffer
116 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
117 | 		test_str_buff.push_back("string" + std::to_string(i));
118 | 	std::vector<std::string> buffer_copy;
119 | 	buffer_copy.reserve(test_str_buff.size());
120 | 	std::copy(test_str_buff.begin(), test_str_buff.end(), std::back_inserter(buffer_copy));
121 | 	int i = 0;
122 | 	for(const auto& elem: test_str_buff)
123 | 		EXPECT_EQ(elem, buffer_copy[i++]);
124 | 	buffer_copy.clear();
125 | 	//remove elements from  buffer
126 | 	for(int i=0; i<REDUCE_SIZE; i++)
127 | 		test_str_buff.pop_front();
128 | 	std::copy(test_str_buff.begin(), test_str_buff.end(), std::back_inserter(buffer_copy));
129 | 	i = 0;
130 | 	for(const auto& elem: test_str_buff)
131 | 		EXPECT_EQ(elem, buffer_copy[i++]);
132 | 	
133 | }
134 | 
135 | 
136 | 
137 | 


--------------------------------------------------------------------------------
/circular_buffer.h:
--------------------------------------------------------------------------------
  1 | #ifndef CIRCULAR_BUFFER_H
  2 | #define CIRCULAR_BUFFER_H
  3 | 
  4 | #include <algorithm>
  5 | #include <iterator>
  6 | #include <mutex>
  7 | #include <memory>
  8 | #include <stdexcept>
  9 | #include <utility>
 10 | 
 11 | 
 12 | template<typename T>
 13 | class CircularBuffer {
 14 | private:
 15 | 	
 16 | 	typedef T* pointer;
 17 | 	typedef const T* const_pointer;
 18 | 	typedef T& reference;
 19 | 	typedef const T& const_reference;
 20 | 	typedef size_t size_type;
 21 | 	typedef ptrdiff_t difference_type;
 22 |     template <bool isConst> struct BufferIterator;
 23 | 	
 24 | 
 25 | public:
 26 |     typedef T value_type;
 27 | 
 28 | 	explicit CircularBuffer(size_t size)
 29 | 		:_buff{std::unique_ptr<T[]>(new value_type[size])}, _max_size{size}{}
 30 | 
 31 | 	CircularBuffer(const CircularBuffer& other)
 32 | 		:_buff{std::unique_ptr<T[]>(new value_type[other._max_size])},
 33 | 		 _max_size{other._max_size},
 34 | 		 _size{other._size},
 35 | 		 _head{other._head},
 36 | 		 _tail{other._tail}{
 37 | 			 std::copy(other.data(), other.data() + _max_size, _buff.get());
 38 | 		 }
 39 | 
 40 | 	
 41 | 	CircularBuffer& operator=(const CircularBuffer& other){
 42 | 		if ( this != &other){
 43 | 			_buff.reset(new value_type[other._max_size]);
 44 | 			_max_size = other._max_size;
 45 | 			_size = other._size;
 46 | 			_head = other._head;
 47 | 			_tail = other._tail;
 48 | 			std::copy(other.data(), other.data() + _max_size, _buff.get());
 49 | 		}
 50 | 		return *this;
 51 | 	}
 52 | 
 53 | 	CircularBuffer(CircularBuffer&& other) noexcept
 54 | 		:_buff{std::move(other._buff)},
 55 | 		 _max_size{other._max_size},
 56 | 		 _size{other._size},
 57 | 		 _head{other._head},
 58 | 		 _tail{other._tail}{
 59 | 
 60 | 		other._buff = nullptr;
 61 | 		other._max_size = 0;
 62 | 		other._size = 0;
 63 | 		other._head = 0;
 64 | 		other._tail = 0;
 65 | 	}
 66 | 
 67 | 	
 68 | 	CircularBuffer& operator=(CircularBuffer&& other) noexcept{
 69 | 		if ( this != &other){
 70 | 			_buff = std::move(other._buff);
 71 | 			_max_size = other._max_size;
 72 | 			_size = other._size;
 73 | 			_head = other._head;
 74 | 			_tail = other._tail;
 75 | 			
 76 | 			other._buff = nullptr;
 77 | 			other._max_size = 0;
 78 | 			other._size = 0;
 79 | 			other._head = 0;
 80 | 			other._tail = 0;			
 81 | 		}
 82 | 		return *this;
 83 | 	}
 84 | 	
 85 | 	void push_back(const value_type& data);
 86 | 	void push_back(value_type&& data) noexcept;
 87 | 	void pop_front();
 88 | 	reference front();
 89 | 	reference back(); 
 90 | 	const_reference front() const; 
 91 | 	const_reference back() const;
 92 | 	void clear();
 93 | 	bool empty() const ;
 94 | 	bool full() const ;
 95 | 	size_type capacity() const ;
 96 | 	size_type size() const;
 97 | 	size_type buffer_size() const {return sizeof(value_type)*_max_size;};
 98 | 	const_pointer data() const { return _buff.get(); }
 99 | 	
100 | 	const_reference operator[](size_type index) const;
101 | 	reference operator[](size_type index);
102 | 	const_reference at(size_type index) const;
103 | 	reference at(size_type index);
104 | 
105 | 	typedef BufferIterator<false> iterator;
106 | 	typedef BufferIterator<true> const_iterator;
107 | 	
108 | 	iterator begin();
109 | 	const_iterator begin() const;
110 | 	iterator end();
111 | 	const_iterator end() const;
112 | 	const_iterator cbegin() const noexcept;
113 | 	const_iterator cend() const noexcept;
114 | 	iterator rbegin() noexcept;
115 | 	const_iterator rbegin() const noexcept;
116 | 	iterator rend() noexcept;
117 | 	const_iterator rend() const noexcept;
118 | 	
119 | 		
120 | private:
121 | 	void _increment_bufferstate();
122 | 	void _decrement_bufferstate();
123 | 	mutable std::mutex _mtx;
124 | 	std::unique_ptr<value_type[]> _buff;
125 | 	size_type _head = 0;
126 | 	size_type _tail = 0;
127 | 	size_type _size = 0;
128 | 	size_type _max_size = 0;
129 | 			
130 |     template<bool isConst = false>
131 | 	struct  BufferIterator{
132 | 	public:
133 | 		friend class CircularBuffer<T>;
134 | 		typedef std::random_access_iterator_tag iterator_category;
135 | 		typedef ptrdiff_t difference_type;
136 | 		typedef T value_type;
137 | 		typedef typename std::conditional<isConst, const value_type&, value_type&>::type reference;
138 | 		typedef typename std::conditional<isConst, const value_type*, value_type*>::type pointer;
139 | 		typedef typename std::conditional<isConst, const CircularBuffer<value_type>*,
140 | 										  CircularBuffer<value_type>*>::type cbuf_pointer;
141 | 	private:
142 | 		cbuf_pointer _ptrToBuffer;
143 | 		size_type _offset;
144 | 		size_type _index;
145 | 		bool _reverse;
146 | 		
147 | 		bool _comparable(const BufferIterator<isConst>& other) const{
148 | 			return (_ptrToBuffer == other._ptrToBuffer)&&(_reverse == other._reverse);
149 | 		}
150 | 		
151 | 	public:
152 | 		BufferIterator()
153 | 			:_ptrToBuffer{nullptr}, _offset{0}, _index{0}, _reverse{false}{}
154 | 		
155 | 		BufferIterator(const BufferIterator<false>& it)
156 | 			:_ptrToBuffer{it._ptrToBuffer},
157 | 			 _offset{it._offset},
158 | 			 _index{it._index},
159 | 			 _reverse{it._reverse}{}
160 | 
161 | 		reference operator*(){
162 | 			if(_reverse)
163 | 				return (*_ptrToBuffer)[(_ptrToBuffer->size() - _index - 1)];
164 | 			return (*_ptrToBuffer)[_index];
165 | 		}
166 | 
167 | 		pointer  operator->() { return &(operator*()); }
168 | 
169 | 		reference operator[](size_type index){
170 | 			BufferIterator iter = *this;
171 | 			iter._index += index;
172 | 			return *iter;
173 | 		}
174 | 
175 | 		BufferIterator& operator++(){
176 | 			++_index;
177 | 			return *this;
178 | 		}
179 | 
180 | 		BufferIterator operator++(int){
181 | 			BufferIterator iter = *this;
182 | 			++_index;
183 | 			return iter;
184 | 		}
185 | 
186 | 		BufferIterator& operator--(){
187 | 			--_index;
188 | 			return *this;
189 | 		}
190 | 
191 | 		BufferIterator operator--(int){
192 | 			BufferIterator iter = *this;
193 | 			--_index;
194 | 			return iter;
195 | 		}	
196 | 
197 | 		friend BufferIterator operator+(BufferIterator lhsiter, difference_type n){
198 | 			lhsiter._index += n;
199 | 			return lhsiter;
200 | 		}
201 | 
202 | 		friend BufferIterator operator+(difference_type n, BufferIterator rhsiter){
203 | 			rhsiter._index += n;
204 | 			return rhsiter;
205 | 		}
206 | 		
207 | 
208 | 		BufferIterator& operator+=(difference_type n){
209 | 			_index += n;
210 | 			return *this;
211 | 		}
212 | 
213 | 		friend BufferIterator operator-(BufferIterator lhsiter, difference_type n){
214 | 			lhsiter._index -= n;
215 | 			return lhsiter;
216 | 		}
217 | 
218 | 		friend difference_type operator-(const BufferIterator& lhsiter, const BufferIterator& rhsiter){
219 | 			
220 | 			return lhsiter._index - rhsiter._index;
221 | 		}
222 | 
223 | 		BufferIterator& operator-=(difference_type n){
224 | 			_index -= n;
225 | 			return *this;
226 | 		}
227 | 
228 | 		bool operator==(const BufferIterator& other) const{
229 | 			if (!_comparable(other))
230 | 				return false;
231 | 			return ((_index == other._index)&&(_offset == other._offset));
232 | 		}
233 | 		
234 | 		bool operator!=(const BufferIterator& other) const{
235 | 			if (!_comparable(other))
236 | 				return true;
237 | 			return ((_index != other._index)||(_offset != other._offset));
238 | 		}
239 | 
240 | 		bool operator<(const BufferIterator& other) const {
241 | 			if (!_comparable(other))
242 | 				return false;
243 | 			return ((_index + _offset)<(other._index+other._offset));
244 | 		}
245 | 
246 | 		bool operator>(const BufferIterator& other) const{
247 | 			if (!_comparable(other))
248 | 				return false;
249 | 			return ((_index + _offset)>(other._index+other._offset));
250 | 		}
251 | 
252 | 		bool operator<=(const BufferIterator& other) const {
253 | 			if (!_comparable(other))
254 | 				return false;
255 | 			return ((_index + _offset)<=(other._index+other._offset));
256 | 		}
257 | 
258 | 		bool operator>=(const BufferIterator& other) const {
259 | 			if (!_comparable(other))
260 | 				return false;
261 | 			return ((_index + _offset)>=(other._index+other._offset));
262 | 		}
263 | 	};
264 | };
265 | 
266 | template<typename T>
267 | inline 
268 | bool CircularBuffer<T>::full() const{
269 | 	return _size == _max_size;
270 | }
271 | 
272 | template<typename T>
273 | inline 
274 | bool CircularBuffer<T>::empty() const{
275 | 	return _size == 0;
276 | }
277 | 
278 | template<typename T>
279 | inline 
280 | typename CircularBuffer<T>::size_type CircularBuffer<T>::capacity() const{
281 | 	return _max_size;
282 | }
283 | 
284 | template<typename T>
285 | inline 
286 | void  CircularBuffer<T>::clear(){
287 | 	std::lock_guard<std::mutex> _lck(_mtx);
288 | 	_head = _tail = _size = 0;
289 | }
290 | 
291 | template<typename T>
292 | inline 
293 | typename CircularBuffer<T>::size_type CircularBuffer<T>::size() const{
294 | 	std::lock_guard<std::mutex> _lck(_mtx);
295 | 	return _size;
296 | 	}
297 | 
298 | template<typename T>
299 | inline
300 | typename CircularBuffer<T>::reference CircularBuffer<T>::front() {
301 | 	std::lock_guard<std::mutex> _lck(_mtx);
302 | 	if(empty())
303 | 		throw std::length_error("front function called on empty buffer");
304 | 	return _buff[_tail];
305 | }
306 | 
307 | template<typename T>
308 | inline
309 | typename CircularBuffer<T>::reference CircularBuffer<T>::back() {
310 | 	std::lock_guard<std::mutex> _lck(_mtx);
311 | 	if(empty())
312 | 		throw std::length_error("back function called on empty buffer");
313 | 	return _head == 0 ? _buff[_max_size - 1] : _buff[_head - 1];
314 | }
315 | 
316 | template<typename T>
317 | inline
318 | typename CircularBuffer<T>::const_reference CircularBuffer<T>::front() const{
319 | 	std::lock_guard<std::mutex> _lck(_mtx);
320 | 	if(empty())
321 | 		throw std::length_error("front function called on empty buffer");
322 | 	return _buff[_tail];
323 | }
324 | 
325 | template<typename T>
326 | inline
327 | typename CircularBuffer<T>::const_reference CircularBuffer<T>::back() const{
328 | 	std::lock_guard<std::mutex> _lck(_mtx);
329 | 	if(empty())
330 | 		throw std::length_error("back function called on empty buffer");
331 | 	return _head == 0 ? _buff[_max_size - 1] : _buff[_head - 1];
332 | }
333 | 
334 | template<typename T>
335 | inline
336 | void CircularBuffer<T>::push_back(const T& data){
337 | 	std::lock_guard<std::mutex> _lck(_mtx);
338 | 	//if(full())
339 | 	//	_buff[_tail].~T();
340 | 	_buff[_head] = data;
341 | 	_increment_bufferstate();
342 | }
343 | 
344 | template<typename T>
345 | inline
346 | void CircularBuffer<T>::push_back(T&& data) noexcept{
347 | 	std::lock_guard<std::mutex> _lck(_mtx);
348 | 	_buff[_head] = std::move(data);
349 | 	_increment_bufferstate();
350 | }
351 | 
352 | 
353 | template<typename T>
354 | inline 
355 | void CircularBuffer<T>::_increment_bufferstate(){
356 | 	if(full())
357 | 		_tail = (_tail + 1)%_max_size;
358 | 	else
359 | 		++_size;
360 | 	_head = (_head + 1)%_max_size;	
361 | }
362 | 
363 | template<typename T>
364 | inline 
365 | void CircularBuffer<T>::pop_front(){
366 | 	std::lock_guard<std::mutex> _lck(_mtx);
367 | 	if(empty())
368 | 		throw std::length_error("pop_front called on empty buffer");
369 | 	_decrement_bufferstate();
370 | }
371 | 
372 | template<typename T>
373 | inline 
374 | void CircularBuffer<T>::_decrement_bufferstate(){
375 | 	--_size;
376 | 	_tail = (_tail + 1)%_max_size;
377 | }
378 | 
379 | template<typename T>
380 | inline 
381 | typename CircularBuffer<T>::reference CircularBuffer<T>::operator[](size_t index) {
382 | 	std::lock_guard<std::mutex> _lck(_mtx);
383 | 	if((index<0)||(index>=_size))
384 | 		throw std::out_of_range("Index is out of Range of buffer size");
385 | 	index += _tail;
386 | 	index %= _max_size;
387 | 	return _buff[index];
388 | }
389 | 
390 | template<typename T>
391 | inline 
392 | typename CircularBuffer<T>::const_reference CircularBuffer<T>::operator[](size_t index) const {
393 | 	std::lock_guard<std::mutex> _lck(_mtx);
394 | 	if((index<0)||(index>=_size))
395 | 		throw std::out_of_range("Index is out of Range of buffer size");
396 | 	index += _tail;
397 | 	index %= _max_size;
398 | 	return _buff[index];
399 | }
400 | 
401 | template<typename T>
402 | inline 
403 | typename CircularBuffer<T>::reference CircularBuffer<T>::at(size_t index) {
404 | 	std::lock_guard<std::mutex> _lck(_mtx);
405 | 	if((index<0)||(index>=_size))
406 | 		throw std::out_of_range("Index is out of Range of buffer size");
407 | 	index += _tail;
408 | 	index %= _max_size;
409 | 	return _buff[index];
410 | }
411 | 
412 | template<typename T>
413 | inline 
414 | typename CircularBuffer<T>::const_reference CircularBuffer<T>::at(size_t index) const {
415 | 	std::lock_guard<std::mutex> _lck(_mtx);
416 | 	if((index<0)||(index>=_size))
417 | 		throw std::out_of_range("Index is out of Range of buffer size");
418 | 	index += _tail;
419 | 	index %= _max_size;
420 | 	return _buff[index];
421 | }
422 | 
423 | template<typename T>
424 | inline 
425 | typename CircularBuffer<T>::iterator CircularBuffer<T>::begin() {
426 | 	std::lock_guard<std::mutex> _lck(_mtx);
427 | 	iterator iter;
428 | 	iter._ptrToBuffer = this;
429 | 	iter._offset = _tail;
430 | 	iter._index = 0;
431 | 	iter._reverse = false;
432 | 	return iter;
433 | }
434 | 
435 | template<typename T>
436 | inline 
437 | typename CircularBuffer<T>::const_iterator CircularBuffer<T>::begin() const{
438 | 	std::lock_guard<std::mutex> _lck(_mtx);
439 | 	const_iterator iter;
440 | 	iter._ptrToBuffer = this;
441 | 	iter._offset = _tail;
442 | 	iter._index = 0;
443 | 	iter._reverse = false;
444 | 	return iter;
445 | }
446 | 
447 | template<typename T>
448 | inline 
449 | typename CircularBuffer<T>::iterator CircularBuffer<T>::end() {
450 | 	std::lock_guard<std::mutex> _lck(_mtx);
451 | 	iterator iter;
452 | 	iter._ptrToBuffer = this;
453 | 	iter._offset = _tail;
454 | 	iter._index = _size;
455 | 	iter._reverse = false;
456 | 	return iter;
457 | }
458 | 
459 | template<typename T>
460 | inline 
461 | typename CircularBuffer<T>::const_iterator CircularBuffer<T>::end() const{
462 | 	std::lock_guard<std::mutex> _lck(_mtx);
463 | 	const_iterator iter;
464 | 	iter._ptrToBuffer = this;
465 | 	iter._offset = _tail;
466 | 	iter._index = _size;
467 | 	iter._reverse = false;
468 | 	return iter;
469 | }
470 | 
471 | template<typename T>
472 | inline 
473 | typename CircularBuffer<T>::const_iterator CircularBuffer<T>::cbegin() const noexcept{
474 | 	std::lock_guard<std::mutex> _lck(_mtx);
475 | 	const_iterator iter;
476 | 	iter._ptrToBuffer = this;
477 | 	iter._offset = _tail;
478 | 	iter._index = 0;
479 | 	iter._reverse = false;
480 | 	return iter;
481 | }
482 | 
483 | template<typename T>
484 | inline 
485 | typename CircularBuffer<T>::const_iterator CircularBuffer<T>::cend() const noexcept{
486 | 	std::lock_guard<std::mutex> _lck(_mtx);
487 | 	const_iterator iter;
488 | 	iter._ptrToBuffer = this;
489 | 	iter._offset = _tail;
490 | 	iter._index = _size;
491 | 	iter._reverse = false;
492 | 	return iter;
493 | }
494 | 
495 | template<typename T>
496 | inline 
497 | typename CircularBuffer<T>::iterator CircularBuffer<T>::rbegin() noexcept{
498 | 	std::lock_guard<std::mutex> _lck(_mtx);
499 | 	iterator iter;
500 | 	iter._ptrToBuffer = this;
501 | 	iter._offset = _tail;
502 | 	iter._index = 0;
503 | 	iter._reverse = true;
504 | 	return iter;
505 | }
506 | 
507 | template<typename T>
508 | inline 
509 | typename CircularBuffer<T>::const_iterator CircularBuffer<T>::rbegin() const noexcept{
510 | 	std::lock_guard<std::mutex> _lck(_mtx);
511 | 	const_iterator iter;
512 | 	iter._ptrToBuffer = this;
513 | 	iter._offset = _tail;
514 | 	iter._index = 0;
515 | 	iter._reverse = true;
516 | 	return iter;
517 | }
518 | 
519 | template<typename T>
520 | inline 
521 | typename CircularBuffer<T>::iterator CircularBuffer<T>::rend()  noexcept{
522 | 	std::lock_guard<std::mutex> _lck(_mtx);
523 | 	iterator iter;
524 | 	iter._ptrToBuffer = this;
525 | 	iter._offset = _tail;
526 | 	iter._index = _size;
527 | 	iter._reverse = true;
528 | 	return iter;
529 | }
530 | 
531 | template<typename T>
532 | inline 
533 | typename CircularBuffer<T>::const_iterator CircularBuffer<T>::rend() const noexcept{
534 | 	std::lock_guard<std::mutex> _lck(_mtx);
535 | 	const_iterator iter;
536 | 	iter._ptrToBuffer = this;
537 | 	iter._offset = _tail;
538 | 	iter._index = _size;
539 | 	iter._reverse = true;
540 | 	return iter;
541 | }
542 | 
543 | #endif /* CIRCULAR_BUFFER_H */
544 | 


--------------------------------------------------------------------------------
/tests/member_func_test.cpp:
--------------------------------------------------------------------------------
  1 | #include "circular_buffer.h"
  2 | #include <string.h>
  3 | #include <utility>
  4 | #include "gtest/gtest.h"
  5 | 
  6 | #define TEST_BUFFER_SIZE 100
  7 | #define REDUCE_SIZE 100
  8 | 
  9 | class CircularBufferTest : public ::testing::Test{
 10 | 	
 11 | protected:
 12 | 	
 13 | 	CircularBuffer<std::string> test_buff{TEST_BUFFER_SIZE};
 14 | 	
 15 | };
 16 | 
 17 | TEST_F(CircularBufferTest, CapacityTest){
 18 | 	EXPECT_EQ(TEST_BUFFER_SIZE, test_buff.capacity());
 19 | 	EXPECT_FALSE(test_buff.capacity() == 0);
 20 | }
 21 | 
 22 | TEST_F(CircularBufferTest, EmptyTest){
 23 | 	EXPECT_TRUE(test_buff.empty());
 24 | 	test_buff.push_back("string 1");
 25 | 	test_buff.push_back("string 2");
 26 | 	EXPECT_FALSE(test_buff.empty());
 27 | 	test_buff.pop_front();
 28 | 	test_buff.pop_front();
 29 | 	EXPECT_TRUE(test_buff.empty());
 30 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
 31 | 		test_buff.push_back("string" + std::to_string(i));
 32 | 	EXPECT_FALSE(test_buff.empty());
 33 | 	
 34 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
 35 | 		test_buff.pop_front();
 36 | 	EXPECT_TRUE(test_buff.empty());
 37 | }
 38 | 
 39 | TEST_F(CircularBufferTest, SizeTest){
 40 | 	EXPECT_TRUE(test_buff.empty());
 41 | 	test_buff.push_back("string 1");
 42 | 	test_buff.push_back("string 2");
 43 | 	EXPECT_EQ(test_buff.size(), 2);
 44 | 	test_buff.pop_front();
 45 | 	test_buff.pop_front();
 46 | 	EXPECT_EQ(test_buff.size(), 0);
 47 | 	// create full buffer
 48 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
 49 | 		test_buff.push_back("string" + std::to_string(i));
 50 | 	EXPECT_EQ(test_buff.size(), TEST_BUFFER_SIZE);
 51 | 	//add more entries to overwrite front
 52 | 	test_buff.push_back("string" + std::to_string(TEST_BUFFER_SIZE + 1));
 53 | 	test_buff.push_back("string" + std::to_string(TEST_BUFFER_SIZE + 2));
 54 | 	EXPECT_EQ(test_buff.size(), TEST_BUFFER_SIZE);
 55 | 	//manually empty buffer
 56 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
 57 | 		test_buff.pop_front();
 58 | 	EXPECT_EQ(test_buff.size(), 0);
 59 | }
 60 | 
 61 | TEST_F(CircularBufferTest, ClearTest){
 62 | 	EXPECT_TRUE(test_buff.empty());
 63 | 	// create full buffer
 64 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
 65 | 		test_buff.push_back("string" + std::to_string(i));	
 66 | 	EXPECT_FALSE(test_buff.empty());
 67 | 	//add more entries to overwrite front
 68 | 	test_buff.push_back("string" + std::to_string(TEST_BUFFER_SIZE + 1));	
 69 | 	EXPECT_FALSE(test_buff.empty());
 70 | 	//clear buffer
 71 | 	test_buff.clear();
 72 | 	//check size and empty flags after clearing
 73 | 	EXPECT_TRUE(test_buff.empty());
 74 | 	EXPECT_EQ(test_buff.size(), 0);
 75 | 	//fill buffer after clear
 76 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
 77 | 		test_buff.push_back("string" + std::to_string(i));
 78 | 
 79 | }
 80 | 
 81 | TEST_F(CircularBufferTest, FullTest){
 82 | 	EXPECT_FALSE(test_buff.full());
 83 | 	// create full buffer
 84 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
 85 | 		test_buff.push_back("string" + std::to_string(i));	
 86 | 	EXPECT_TRUE(test_buff.full());
 87 | 	//add more entries to overwrite front
 88 | 	test_buff.push_back("string" + std::to_string(TEST_BUFFER_SIZE + 1));	
 89 | 	EXPECT_TRUE(test_buff.full());
 90 | 	//remove front element
 91 | 	test_buff.pop_front();
 92 | 	EXPECT_FALSE(test_buff.full());
 93 | 	//add one elememt to make the buffer full
 94 | 	test_buff.push_back("string" + std::to_string(TEST_BUFFER_SIZE + 2));		
 95 | 	EXPECT_TRUE(test_buff.full());
 96 | }
 97 | 
 98 | 
 99 | TEST_F(CircularBufferTest, PushBackTest){
100 | 	// push back individual elements
101 | 	test_buff.push_back("string1");	
102 | 	EXPECT_EQ(test_buff.size(), 1);
103 | 	test_buff.push_back("string2");	
104 | 	EXPECT_EQ(test_buff.size(), 2);
105 | 	//create full buffer
106 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
107 | 		test_buff.push_back("string" + std::to_string(i));
108 | 	
109 | 	//test move semantics in push_back
110 | 	std::string string_to_move{"This string is moved"};
111 | 	test_buff.push_back(std::move(string_to_move));	
112 | 	EXPECT_TRUE(string_to_move.empty());
113 | 	//create full buffer
114 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++){
115 | 		std::string temp_string{"This string is moved"};
116 | 		test_buff.push_back(std::move(temp_string));
117 | 		EXPECT_TRUE(temp_string.empty());
118 | 	}	
119 | 	EXPECT_TRUE(test_buff.full());
120 | 	EXPECT_EQ(test_buff.size(), TEST_BUFFER_SIZE);
121 | 	
122 | }
123 | 
124 | 
125 | TEST_F(CircularBufferTest, PopFrontTest){
126 | 	// push back & pop individual elements
127 | 	test_buff.push_back("string1");
128 | 	EXPECT_EQ(test_buff.size(), 1);
129 | 	test_buff.pop_front();	
130 | 	EXPECT_EQ(test_buff.size(), 0);
131 | 	
132 | 	//create full buffer
133 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
134 | 		test_buff.push_back("string" + std::to_string(i));
135 | 	//pop all elements
136 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
137 | 		test_buff.pop_front();
138 | 	EXPECT_TRUE(test_buff.empty());
139 | 	EXPECT_EQ(test_buff.size(), 0);
140 | 	//try pop on empty buffer
141 | 	try {
142 | 		test_buff.pop_front();
143 | 		FAIL() << "Expected std::length_error";
144 | 	}
145 | 	catch(const std::length_error& err){
146 | 		EXPECT_EQ(err.what(), std::string("pop_front called on empty buffer"));
147 | 	}
148 | }
149 | 
150 | 
151 | TEST_F(CircularBufferTest, FrontTest){
152 | 	// push back & front for  individual elements
153 | 	test_buff.push_back("string1");
154 | 	test_buff.push_back("string2");
155 | 	EXPECT_EQ(test_buff.size(), 2);
156 | 	EXPECT_EQ(test_buff.front(), "string1");
157 | 	test_buff.front() = "string2";
158 | 	EXPECT_EQ(test_buff.front(), "string2");
159 | 	//create full buffer
160 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
161 | 		test_buff.push_back("string" + std::to_string(i));
162 | 	EXPECT_EQ(test_buff.front(), "string0");
163 | 	//empty the buffer
164 | 	test_buff.clear();
165 | 	EXPECT_EQ(test_buff.size(), 0);
166 | 	//calling front on empty buffer raises exception
167 | 	try {
168 | 		test_buff.front() = "string0";
169 | 		FAIL() << "Expected std::length_error";
170 | 	}
171 | 	catch(const std::length_error& err){
172 | 		EXPECT_EQ(err.what(), std::string("front function called on empty buffer"));
173 | 	}
174 | }
175 | 
176 | TEST_F(CircularBufferTest, BackTest){
177 | 	// push back & front for  individual elements
178 | 	test_buff.push_back("string1");
179 | 	test_buff.push_back("string2");
180 | 	EXPECT_EQ(test_buff.size(), 2);
181 | 	EXPECT_EQ(test_buff.back(), "string2");
182 | 	test_buff.back() = "string1";
183 | 	EXPECT_EQ(test_buff.back(), "string1");
184 | 	//create full buffer
185 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
186 | 		test_buff.push_back("string" + std::to_string(i));
187 | 	EXPECT_EQ(test_buff.back(), "string99");
188 | 	//empty the buffer
189 | 	test_buff.clear();
190 | 	EXPECT_EQ(test_buff.size(), 0);
191 | 	//calling back on empty buffer raises exception
192 | 	try {
193 | 		test_buff.back() = "string0";
194 | 		FAIL() << "Expected std::length_error";
195 | 	}
196 | 	catch(const std::length_error& err){
197 | 		EXPECT_EQ(err.what(), std::string("back function called on empty buffer"));
198 | 	}
199 |  
200 | }
201 | 
202 | TEST_F(CircularBufferTest, AtFunctionTest){
203 | 	// push back & at access for  individual elements
204 | 	test_buff.push_back("string1");
205 | 	test_buff.push_back("string2");
206 | 	EXPECT_EQ(test_buff.size(), 2);
207 | 	EXPECT_EQ(test_buff.at(0), "string1");
208 | 	EXPECT_EQ(test_buff.at(1), "string2");
209 | 	test_buff.at(0) = "string2";
210 | 	test_buff.at(1) = "string1";
211 | 	EXPECT_EQ(test_buff.at(0), "string2");
212 | 	EXPECT_EQ(test_buff.at(1), "string1");
213 | 	//create full buffer
214 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
215 | 		test_buff.push_back("string" + std::to_string(i));
216 | 	//test at function for each element
217 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
218 | 		EXPECT_EQ(test_buff.at(i), "string" + std::to_string(i));
219 | 	//test assignment with at function for each element
220 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
221 | 		test_buff.at(i) = "test_string" ;
222 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
223 | 		EXPECT_EQ(test_buff.at(i),"test_string");
224 | 	//test out of bounds
225 | 	try {
226 | 		test_buff.at(TEST_BUFFER_SIZE) = "test_string";
227 | 		FAIL() << "Expected std::out_of_range error";
228 | 	}
229 | 	catch(const std::out_of_range& err){
230 | 		EXPECT_EQ(err.what(), std::string("Index is out of Range of buffer size"));
231 | 	}
232 | 	//test out of size
233 | 	test_buff.pop_front();
234 | 	try {
235 | 		test_buff.at(TEST_BUFFER_SIZE - 1) = "test_string";
236 | 		FAIL() << "Expected std::out_of_range error";
237 | 	}
238 | 	catch(const std::out_of_range& err){
239 | 		EXPECT_EQ(err.what(), std::string("Index is out of Range of buffer size"));
240 | 	}
241 | }
242 | 
243 | TEST_F(CircularBufferTest, AccessOperatorTest){
244 | 	// push back & [] access for  individual elements
245 | 	test_buff.push_back("string1");
246 | 	test_buff.push_back("string2");
247 | 	EXPECT_EQ(test_buff.size(), 2);
248 | 	EXPECT_EQ(test_buff[0], "string1");
249 | 	EXPECT_EQ(test_buff[1], "string2");
250 | 	test_buff[0] = "string2";
251 | 	test_buff[1] = "string1";
252 | 	EXPECT_EQ(test_buff[0], "string2");
253 | 	EXPECT_EQ(test_buff[1], "string1");
254 | 	//create full buffer
255 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
256 | 		test_buff.push_back("string" + std::to_string(i));
257 | 	//test [] operator for each element
258 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
259 | 		EXPECT_EQ(test_buff[i], "string" + std::to_string(i));
260 | 	//test assignment with [] operator for each element
261 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
262 | 		test_buff[i] = "test_string" ;
263 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
264 | 		EXPECT_EQ(test_buff[i],"test_string");
265 | 	//test out of bounds
266 | 	try {
267 | 		test_buff[TEST_BUFFER_SIZE] = "test_string";
268 | 		FAIL() << "Expected std::out_of_range error";
269 | 	}
270 | 	catch(const std::out_of_range& err){
271 | 		EXPECT_EQ(err.what(), std::string("Index is out of Range of buffer size"));
272 | 	}
273 | 	//test out of size
274 | 	test_buff.pop_front();
275 | 	try {
276 | 		test_buff[TEST_BUFFER_SIZE - 1] = "test_string";
277 | 		FAIL() << "Expected std::out_of_range error";
278 | 	}
279 | 	catch(const std::out_of_range& err){
280 | 		EXPECT_EQ(err.what(), std::string("Index is out of Range of buffer size"));
281 | 	}
282 | }
283 | 
284 | 
285 | TEST_F(CircularBufferTest, BeginIteratorTest){	
286 | 	//create full buffer
287 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
288 | 		test_buff.push_back("string" + std::to_string(i));
289 |     //test first element with iterator
290 | 	CircularBuffer<std::string>::iterator it = test_buff.begin();
291 | 	EXPECT_EQ(*it, "string0" );
292 | 	//access with begin iterator	
293 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
294 | 		EXPECT_EQ(*(it++), "string" + std::to_string(i));
295 | 
296 | 	//access with const begin iterator
297 | 	CircularBuffer<std::string>::const_iterator const_it = test_buff.begin(); 
298 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
299 | 		EXPECT_EQ(*(const_it++), "string" + std::to_string(i));
300 | 	//test out of bounds
301 | 	try {
302 | 		*it = "test_string";
303 | 		FAIL() << "Expected std::out_of_range error";
304 | 	}
305 | 	catch(const std::out_of_range& err){
306 | 		EXPECT_EQ(err.what(), std::string("Index is out of Range of buffer size"));
307 | 	}
308 | 
309 | 	try {
310 | 		std::string out_of_bound = *(const_it);
311 | 		FAIL() << "Expected std::out_of_range error";
312 | 	}
313 | 	catch(const std::out_of_range& err){
314 | 		EXPECT_EQ(err.what(), std::string("Index is out of Range of buffer size"));
315 | 	}
316 | }
317 | 
318 | TEST_F(CircularBufferTest, RbeginIteratorTest){	
319 | 	//create full buffer
320 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
321 | 		test_buff.push_back("string" + std::to_string(i));
322 |     //test first element with iterator
323 | 	CircularBuffer<std::string>::iterator it = test_buff.rbegin();
324 | 	//access with rbegin iterator	
325 | 	for(int i=TEST_BUFFER_SIZE-1; i>=0; i--)
326 | 		EXPECT_EQ(*(it++), "string" + std::to_string(i));
327 | 
328 | 	//access with const begin iterator
329 | 	CircularBuffer<std::string>::const_iterator const_it = test_buff.rbegin(); 
330 | 	for(int i=TEST_BUFFER_SIZE - 1; i>=0;  i--)
331 | 		EXPECT_EQ(*(const_it++), "string" + std::to_string(i));
332 | 	//test out of bounds
333 | 	try {
334 | 		*it = "test_string";
335 | 		FAIL() << "Expected std::out_of_range error";
336 | 	}
337 | 	catch(const std::out_of_range& err){
338 | 		EXPECT_EQ(err.what(), std::string("Index is out of Range of buffer size"));
339 | 	}
340 | 
341 | 	try {
342 | 		std::string out_of_bound = *(const_it);
343 | 		FAIL() << "Expected std::out_of_range error";
344 | 	}
345 | 	catch(const std::out_of_range& err){
346 | 		EXPECT_EQ(err.what(), std::string("Index is out of Range of buffer size"));
347 | 		}
348 | }
349 | 
350 | TEST_F(CircularBufferTest, CbeginIteratorTest){	
351 | 	//create full buffer
352 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
353 | 		test_buff.push_back("string" + std::to_string(i));
354 |     //test first element with iterator
355 | 	CircularBuffer<std::string>::const_iterator const_it = test_buff.cbegin();
356 | 	EXPECT_EQ(*const_it, "string0" );
357 | 	//access with begin iterator	
358 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
359 | 		EXPECT_EQ(*(const_it++), "string" + std::to_string(i));
360 | 	
361 | 	try {
362 | 		std::string out_of_bound = *(const_it);
363 | 		FAIL() << "Expected std::out_of_range error";
364 | 	}
365 | 	catch(const std::out_of_range& err){
366 | 		EXPECT_EQ(err.what(), std::string("Index is out of Range of buffer size"));
367 | 	}
368 | }
369 | 
370 | 
371 | TEST_F(CircularBufferTest, EndIteratorTest){	
372 | 	//create full buffer
373 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
374 | 		test_buff.push_back("string" + std::to_string(i));
375 | 
376 | 	CircularBuffer<std::string>::iterator it = test_buff.end(); 
377 | 	//access with end iterator	
378 | 	for(int i = TEST_BUFFER_SIZE-1; i>=0; i--)
379 | 		EXPECT_EQ(*(--it), "string" + std::to_string(i));
380 | 
381 | 	//access with const end iterator
382 | 	CircularBuffer<std::string>::const_iterator const_it = test_buff.end(); 
383 | 	for(int i = TEST_BUFFER_SIZE-1; i>=0; i--)
384 | 		EXPECT_EQ(*(--const_it), "string" + std::to_string(i));
385 | 
386 | 	//test out of bounds
387 | 	try {
388 | 		*(--it) = "test_string";
389 | 		FAIL() << "Expected std::out_of_range error";
390 | 	}
391 | 	catch(const std::out_of_range& err){
392 | 		EXPECT_EQ(err.what(), std::string("Index is out of Range of buffer size"));
393 | 	}
394 | 
395 | 	try {
396 | 		std::string out_of_bound = *(--const_it);
397 | 		FAIL() << "Expected std::out_of_range error";
398 | 	}
399 | 	catch(const std::out_of_range& err){
400 | 		EXPECT_EQ(err.what(), std::string("Index is out of Range of buffer size"));
401 | 	}
402 | }
403 | 
404 | TEST_F(CircularBufferTest, RendIteratorTest){	
405 | 	//create full buffer
406 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
407 | 		test_buff.push_back("string" + std::to_string(i));
408 |     //test first element with iterator
409 | 	CircularBuffer<std::string>::iterator it = test_buff.rend() - 1;
410 | 	//access with rbegin iterator	
411 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
412 | 		EXPECT_EQ(*(it--), "string" + std::to_string(i));
413 | 
414 | 	//access with const begin iterator
415 | 	CircularBuffer<std::string>::const_iterator const_it = test_buff.rend() - 1; 
416 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
417 | 		EXPECT_EQ(*(const_it--), "string" + std::to_string(i));
418 | 	//test out of bounds
419 | 	try {
420 | 		*it = "test_string";
421 | 		FAIL() << "Expected std::out_of_range error";
422 | 	}
423 | 	catch(const std::out_of_range& err){
424 | 		EXPECT_EQ(err.what(), std::string("Index is out of Range of buffer size"));
425 | 	}
426 | 
427 | 	try {
428 | 		std::string out_of_bound = *(const_it);
429 | 		FAIL() << "Expected std::out_of_range error";
430 | 	}
431 | 	catch(const std::out_of_range& err){
432 | 		EXPECT_EQ(err.what(), std::string("Index is out of Range of buffer size"));
433 | 		}
434 | }
435 | 
436 | 
437 | TEST_F(CircularBufferTest, CendIteratorTest){	
438 | 	//create full buffer
439 | 	for(int i=0; i<TEST_BUFFER_SIZE; i++)
440 | 		test_buff.push_back("string" + std::to_string(i));
441 | 
442 | 	CircularBuffer<std::string>::const_iterator const_it = test_buff.cend(); 
443 | 	//access with end iterator	
444 | 	for(int i = TEST_BUFFER_SIZE-1; i>=0; i--)
445 | 		EXPECT_EQ(*(--const_it), "string" + std::to_string(i));
446 | 
447 | 	try {
448 | 		std::string out_of_bound = *(--const_it);
449 | 		FAIL() << "Expected std::out_of_range error";
450 | 	}
451 | 	catch(const std::out_of_range& err){
452 | 		EXPECT_EQ(err.what(), std::string("Index is out of Range of buffer size"));
453 | 	}	
454 | }
455 | 
456 | 
457 | 
458 | 
459 | 
460 | 
461 | 
462 | 
463 | 
464 | 
465 | 
466 | 
467 | 
468 | 
469 | 
470 | 
471 | 
472 | 
473 | 
474 | 
475 | 
476 | 


--------------------------------------------------------------------------------