File: ping_array_test.cc

package info (click to toggle)
libtoxcore 0.2.9-1
  • links: PTS, VCS
  • area: main
  • in suites: buster
  • size: 3,096 kB
  • sloc: ansic: 35,423; cpp: 1,526; sh: 642; python: 197; makefile: 78
file content (119 lines) | stat: -rw-r--r-- 3,906 bytes parent folder | download | duplicates (2)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
#include "ping_array.h"

#include <memory>

#include <gtest/gtest.h>
#include "mono_time.h"

namespace {

struct Ping_Array_Deleter {
  void operator()(Ping_Array *arr) { ping_array_kill(arr); }
};

using Ping_Array_Ptr = std::unique_ptr<Ping_Array, Ping_Array_Deleter>;

struct Mono_Time_Deleter {
  void operator()(Mono_Time *arr) { mono_time_free(arr); }
};

using Mono_Time_Ptr = std::unique_ptr<Mono_Time, Mono_Time_Deleter>;

TEST(PingArray, MinimumTimeoutIsOne) {
  EXPECT_EQ(ping_array_new(1, 0), nullptr);
  EXPECT_NE(Ping_Array_Ptr(ping_array_new(1, 1)), nullptr);
}

TEST(PingArray, MinimumArraySizeIsOne) {
  EXPECT_EQ(ping_array_new(0, 1), nullptr);
  EXPECT_NE(Ping_Array_Ptr(ping_array_new(1, 1)), nullptr);
}

TEST(PingArray, ArraySizeMustBePowerOfTwo) {
  Ping_Array_Ptr arr;
  arr.reset(ping_array_new(2, 1));
  EXPECT_NE(arr, nullptr);
  arr.reset(ping_array_new(4, 1));
  EXPECT_NE(arr, nullptr);
  arr.reset(ping_array_new(1024, 1));
  EXPECT_NE(arr, nullptr);

  EXPECT_EQ(ping_array_new(1023, 1), nullptr);
  EXPECT_EQ(ping_array_new(1234, 1), nullptr);
}

TEST(PingArray, StoredDataCanBeRetrieved) {
  Ping_Array_Ptr const arr(ping_array_new(2, 1));
  Mono_Time_Ptr const mono_time(mono_time_new());

  uint64_t const ping_id =
      ping_array_add(arr.get(), mono_time.get(), std::vector<uint8_t>{1, 2, 3, 4}.data(), 4);
  EXPECT_NE(ping_id, 0);

  std::vector<uint8_t> data(4);
  EXPECT_EQ(ping_array_check(arr.get(), mono_time.get(), data.data(), data.size(), ping_id), 4);
  EXPECT_EQ(data, std::vector<uint8_t>({1, 2, 3, 4}));
}

TEST(PingArray, RetrievingDataWithTooSmallOutputBufferHasNoEffect) {
  Ping_Array_Ptr const arr(ping_array_new(2, 1));
  Mono_Time_Ptr const mono_time(mono_time_new());

  uint64_t const ping_id =
      ping_array_add(arr.get(), mono_time.get(), (std::vector<uint8_t>{1, 2, 3, 4}).data(), 4);
  EXPECT_NE(ping_id, 0);

  std::vector<uint8_t> data(4);
  EXPECT_EQ(ping_array_check(arr.get(), mono_time.get(), data.data(), 3, ping_id), -1);
  // It doesn't write anything to the data array.
  EXPECT_EQ(data, std::vector<uint8_t>({0, 0, 0, 0}));
  // Afterwards, we can still read it.
  EXPECT_EQ(ping_array_check(arr.get(), mono_time.get(), data.data(), 4, ping_id), 4);
  EXPECT_EQ(data, std::vector<uint8_t>({1, 2, 3, 4}));
}

TEST(PingArray, ZeroLengthDataCanBeAdded) {
  Ping_Array_Ptr const arr(ping_array_new(2, 1));
  Mono_Time_Ptr const mono_time(mono_time_new());

  uint64_t const ping_id = ping_array_add(arr.get(), mono_time.get(), nullptr, 0);
  EXPECT_NE(ping_id, 0);

  EXPECT_EQ(ping_array_check(arr.get(), mono_time.get(), nullptr, 0, ping_id), 0);
}

TEST(PingArray, PingId0IsInvalid) {
  Ping_Array_Ptr const arr(ping_array_new(2, 1));
  Mono_Time_Ptr const mono_time(mono_time_new());

  EXPECT_EQ(ping_array_check(arr.get(), mono_time.get(), nullptr, 0, 0), -1);
}

// Protection against replay attacks.
TEST(PingArray, DataCanOnlyBeRetrievedOnce) {
  Ping_Array_Ptr const arr(ping_array_new(2, 1));
  Mono_Time_Ptr const mono_time(mono_time_new());

  uint64_t const ping_id = ping_array_add(arr.get(), mono_time.get(), nullptr, 0);
  EXPECT_NE(ping_id, 0);

  EXPECT_EQ(ping_array_check(arr.get(), mono_time.get(), nullptr, 0, ping_id), 0);
  EXPECT_EQ(ping_array_check(arr.get(), mono_time.get(), nullptr, 0, ping_id), -1);
}

TEST(PingArray, PingIdMustMatchOnCheck) {
  Ping_Array_Ptr const arr(ping_array_new(1, 1));
  Mono_Time_Ptr const mono_time(mono_time_new());

  uint64_t const ping_id = ping_array_add(arr.get(), mono_time.get(), nullptr, 0);
  EXPECT_NE(ping_id, 0);

  uint64_t const bad_ping_id = ping_id == 1 ? 2 : 1;

  // bad_ping_id will also be pointing at the same element, but won't match the
  // actual ping_id.
  EXPECT_EQ(ping_array_check(arr.get(), mono_time.get(), nullptr, 0, bad_ping_id), -1);
  EXPECT_EQ(ping_array_check(arr.get(), mono_time.get(), nullptr, 0, ping_id), 0);
}

}  // namespace