fifo_test.cc revision f2477e01787aa58f445919b809d89e252beef54f 
1/* Copyright (c) 2013 The Chromium Authors. All rights reserved.
2 * Use of this source code is governed by a BSD-style license that can be
3 * found in the LICENSE file.
4 */
5
6#include <errno.h>
7#include <fcntl.h>
8#include <pthread.h>
9#include <stdio.h>
10#include <sys/ioctl.h>
11#include <sys/stat.h>
12#include <sys/time.h>
13
14#include "gtest/gtest.h"
15
16#include "nacl_io/fifo_char.h"
17#include "nacl_io/fifo_null.h"
18#include "nacl_io/fifo_packet.h"
19#include "nacl_io/packet.h"
20
21#include "ppapi_simple/ps.h"
22
23using namespace nacl_io;
24
25namespace {
26const size_t kTestSize = 32;
27const size_t kHalfSize = kTestSize / 2;
28const size_t kQuarterSize = kTestSize / 4;
29};
30
31TEST(FIFONull, Basic) {
32  FIFONull fifo;
33  EXPECT_FALSE(fifo.IsFull());
34  EXPECT_FALSE(fifo.IsEmpty());
35
36  EXPECT_LT(0, fifo.ReadAvailable());
37  EXPECT_LT(0, fifo.WriteAvailable());
38}
39
40/**
41 * Test writes that start a wrapped location.  We had
42 * a bug where writes that wrapped around were fine but
43 * bytes that started at a wrapped location were being
44 * written to the wrong loction.
45 */
46TEST(FIFOChar, WriteWrapped) {
47  char temp_wr[kTestSize * 2];
48  char temp_rd[kTestSize * 2];
49  size_t wr_offs = 0;
50  size_t rd_offs = 0;
51
52  memset(temp_rd, 0, sizeof(temp_rd));
53  for (size_t index = 0; index < sizeof(temp_wr); index++)
54    temp_wr[index] = index;
55
56  FIFOChar fifo(kTestSize);
57
58  // Fill the fifo
59  wr_offs += fifo.Write(temp_wr + wr_offs, kTestSize);
60  EXPECT_EQ(kTestSize, wr_offs);
61
62  // Read 1/2 of it
63  rd_offs += fifo.Read(temp_rd + rd_offs, kHalfSize);
64  EXPECT_EQ(kHalfSize, rd_offs);
65
66  // Write the next two quaters.  The second
67  // of these calls to write start at a wrapped
68  // location 1/4 of the way into the fifo
69  wr_offs += fifo.Write(temp_wr + wr_offs, kQuarterSize);
70  EXPECT_EQ(kTestSize + kQuarterSize, wr_offs);
71  wr_offs += fifo.Write(temp_wr + wr_offs, kQuarterSize);
72  EXPECT_EQ(kTestSize + kHalfSize, wr_offs);
73
74  // Finally read all the bytes we wrote.
75  rd_offs += fifo.Read(temp_rd + rd_offs, kTestSize);
76  EXPECT_EQ(kTestSize + kHalfSize, rd_offs);
77
78  for (size_t i = 0; i < rd_offs; i++)
79    ASSERT_EQ((char)i, temp_rd[i]) << "fifo mismatch at pos:" << i;
80}
81
82TEST(FIFOChar, Wrap) {
83  char temp_wr[kTestSize * 2];
84  char temp_rd[kTestSize * 2];
85  size_t wr_offs = 0;
86  size_t rd_offs = 0;
87
88  FIFOChar fifo(kTestSize);
89
90  memset(temp_rd, 0, sizeof(temp_rd));
91  for (size_t index = 0; index < sizeof(temp_wr); index++)
92    temp_wr[index] = index;
93
94  EXPECT_TRUE(fifo.IsEmpty());
95  EXPECT_FALSE(fifo.IsFull());
96
97  // Wrap read and write differently, and verify copy is correct
98  EXPECT_EQ(0, fifo.ReadAvailable());
99  EXPECT_EQ(kTestSize, fifo.WriteAvailable());
100
101  wr_offs += fifo.Write(temp_wr, kHalfSize);
102  EXPECT_EQ(kHalfSize, wr_offs);
103
104  EXPECT_FALSE(fifo.IsEmpty());
105  EXPECT_FALSE(fifo.IsFull());
106
107  rd_offs += fifo.Read(temp_rd, kQuarterSize);
108  EXPECT_EQ(kQuarterSize, rd_offs);
109
110  EXPECT_FALSE(fifo.IsEmpty());
111  EXPECT_FALSE(fifo.IsFull());
112
113  wr_offs += fifo.Write(&temp_wr[wr_offs], kTestSize);
114  EXPECT_EQ(kTestSize + kQuarterSize, wr_offs);
115
116  EXPECT_FALSE(fifo.IsEmpty());
117
118  rd_offs += fifo.Read(&temp_rd[rd_offs], kTestSize);
119  EXPECT_EQ(kTestSize + kQuarterSize, rd_offs);
120
121  EXPECT_TRUE(fifo.IsEmpty());
122  EXPECT_FALSE(fifo.IsFull());
123
124  for (size_t index = 0; index < kQuarterSize + kTestSize; index++)
125    EXPECT_EQ((char) index, temp_rd[index]);
126}
127
128TEST(FIFOPacket, Packets) {
129  char temp_wr[kTestSize];
130  FIFOPacket fifo(kTestSize);
131
132  Packet pkt0(NULL);
133  Packet pkt1(NULL);
134  pkt0.Copy(temp_wr, kHalfSize, 0);
135  pkt1.Copy(temp_wr, kTestSize, 0);
136
137  EXPECT_TRUE(fifo.IsEmpty());
138  EXPECT_FALSE(fifo.IsFull());
139
140  EXPECT_EQ(0, fifo.ReadAvailable());
141  EXPECT_EQ(kTestSize, fifo.WriteAvailable());
142
143  fifo.WritePacket(&pkt0);
144  EXPECT_FALSE(fifo.IsEmpty());
145  EXPECT_FALSE(fifo.IsFull());
146
147  EXPECT_EQ(kHalfSize, fifo.ReadAvailable());
148  EXPECT_EQ(kHalfSize, fifo.WriteAvailable());
149
150  fifo.WritePacket(&pkt1);
151  EXPECT_FALSE(fifo.IsEmpty());
152  EXPECT_TRUE(fifo.IsFull());
153
154  EXPECT_EQ(kHalfSize + kTestSize, fifo.ReadAvailable());
155  EXPECT_EQ(0, fifo.WriteAvailable());
156
157  EXPECT_EQ(&pkt0, fifo.ReadPacket());
158  EXPECT_FALSE(fifo.IsEmpty());
159  EXPECT_TRUE(fifo.IsFull());
160
161  EXPECT_EQ(kTestSize, fifo.ReadAvailable());
162  EXPECT_EQ(0, fifo.WriteAvailable());
163
164  EXPECT_EQ(&pkt1, fifo.ReadPacket());
165
166  EXPECT_TRUE(fifo.IsEmpty());
167  EXPECT_FALSE(fifo.IsFull());
168
169  EXPECT_EQ(0, fifo.ReadAvailable());
170  EXPECT_EQ(kTestSize, fifo.WriteAvailable());
171}
172