src/unittest/circlebuf.cc

   1 /*
   2  * Copyright (c) 2015 ARM Limited
   3  * All rights reserved
   4  *
   5  * The license below extends only to copyright in the software and shall
   6  * not be construed as granting a license to any other intellectual
   7  * property including but not limited to intellectual property relating
   8  * to a hardware implementation of the functionality of the software
   9  * licensed hereunder.  You may use the software subject to the license
  10  * terms below provided that you ensure that this notice is replicated
  11  * unmodified and in its entirety in all distributions of the software,
  12  * modified or unmodified, in source code or in binary form.
  13  *
  14  * Redistribution and use in source and binary forms, with or without
  15  * modification, are permitted provided that the following conditions are
  16  * met: redistributions of source code must retain the above copyright
  17  * notice, this list of conditions and the following disclaimer;
  18  * redistributions in binary form must reproduce the above copyright
  19  * notice, this list of conditions and the following disclaimer in the
  20  * documentation and/or other materials provided with the distribution;
  21  * neither the name of the copyright holders nor the names of its
  22  * contributors may be used to endorse or promote products derived from
  23  * this software without specific prior written permission.
  24  *
  25  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  26  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  27  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  28  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  29  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  30  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  31  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  32  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  33  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  34  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  35  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  36  *
  37  * Authors: Andreas Sandberg
  38  */
  39
  40 #include "base/circlebuf.hh"
  41
  42 #include "unittest/unittest.hh"
  43
  44 const char data[] = {
  45     0x0, 0x1, 0x2, 0x3, 0x4, 0x5, 0x6, 0x7,
  46     0x8, 0x9, 0xa, 0xb, 0xc, 0xd, 0xe, 0xf,
  47 };
  48
  49 int
  50 main(int argc, char *argv[])
  51 {
  52     UnitTest::setCase("Basic non-overflow functionality");
  53     {
  54         CircleBuf<char> buf(8);
  55         char foo[16];
  56
  57         // Write empty buffer, no overflow
  58         buf.write(data, 8);
  59         EXPECT_EQ(buf.size(), 8);
  60         buf.peek(foo, 8);
  61         EXPECT_EQ(memcmp(foo, data, 8), 0);
  62
  63         // Read 2
  64         buf.read(foo, 2);
  65         EXPECT_EQ(memcmp(foo, data, 2), 0);
  66         EXPECT_EQ(buf.size(), 6);
  67         buf.read(foo, 6);
  68         EXPECT_EQ(memcmp(foo, data + 2, 6), 0);
  69         EXPECT_EQ(buf.size(), 0);
  70     }
  71
  72     UnitTest::setCase("Basic single write overflow functionality");
  73     {
  74         CircleBuf<char> buf(8);
  75         char foo[16];
  76
  77         buf.write(data, 16);
  78         EXPECT_EQ(buf.size(), 8);
  79         buf.peek(foo, 8);
  80         EXPECT_EQ(memcmp(data + 8, foo, 8), 0);
  81     }
  82
  83
  84     UnitTest::setCase("Multi-write overflow functionality");
  85     {
  86         CircleBuf<char> buf(8);
  87         char foo[16];
  88
  89         // Write, no overflow, write overflow
  90         buf.write(data, 6);
  91         buf.write(data + 8, 6);
  92         EXPECT_EQ(buf.size(), 8);
  93         buf.peek(foo, 8);
  94         EXPECT_EQ(memcmp(data + 4, foo, 2), 0);
  95         EXPECT_EQ(memcmp(data + 8, foo + 2, 6), 0);
  96     }
  97
  98     UnitTest::setCase("Pointer wrap around");
  99     {
 100         CircleBuf<char> buf(8);
 101         char foo[16];
 102
 103         // _start == 0, _stop = 8
 104         buf.write(data, 8);
 105         // _start == 4, _stop = 8
 106         buf.read(foo, 4);
 107         // _start == 4, _stop = 12
 108         buf.write(data + 8, 4);
 109         EXPECT_EQ(buf.size(), 8);
 110         // _start == 10, _stop = 12
 111         // Normalized: _start == 2, _stop = 4
 112         buf.read(foo + 4, 6);
 113         EXPECT_EQ(buf.size(), 2);
 114         EXPECT_EQ(memcmp(data, foo, 10), 0);
 115         // Normalized: _start == 4, _stop = 4
 116         buf.read(foo + 10, 2);
 117         EXPECT_EQ(buf.size(), 0);
 118         EXPECT_EQ(memcmp(data, foo, 12), 0);
 119     }
 120
 121     return UnitTest::printResults();
 122 }