← Back to branch summary

~evarlast/ubuntu/utopic/mongodb/upstart-workaround-debian-bug-718702

« back to all changes in this revision

Viewing changes to src/third_party/s2/s1angle_test.cc

  • Committer: Package Import Robot
  • Author(s): James Page, James Page, Robie Basak
  • Date: 2013-05-29 17:44:42 UTC
  • mfrom: (44.1.7 sid)
  • Revision ID: package-import@ubuntu.com-20130529174442-z0a4qmoww4y0t458
Tags: 1:2.4.3-1ubuntu1
[ James Page ]
* Merge from Debian unstable, remaining changes:
  - Enable SSL support:
    + d/control: Add libssl-dev to BD's.
    + d/rules: Enabled --ssl option.
    + d/mongodb.conf: Add example SSL configuration options.
  - d/mongodb-server.mongodb.upstart: Add upstart configuration.
  - d/rules: Don't strip binaries during scons build for Ubuntu.
  - d/control: Add armhf to target archs.
  - d/p/SConscript.client.patch: fixup install of client libraries.
  - d/p/0010-install-libs-to-usr-lib-not-usr-lib64-Closes-588557.patch:
    Install libraries to lib not lib64.
* Dropped changes:
  - d/p/arm-support.patch: Included in Debian.
  - d/p/double-alignment.patch: Included in Debian.
  - d/rules,control: Debian also builds with avaliable system libraries
    now.
* Fix FTBFS due to gcc and boost upgrades in saucy:
  - d/p/0008-ignore-unused-local-typedefs.patch: Add -Wno-unused-typedefs
    to unbreak building with g++-4.8.
  - d/p/0009-boost-1.53.patch: Fixup signed/unsigned casting issue.

[ Robie Basak ]
* d/p/0011-Use-a-signed-char-to-store-BSONType-enumerations.patch: Fixup
  build failure on ARM due to missing signed'ness of char cast.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/third_party/s2/s1angle_test.cc
 
1
// Copyright 2005 Google Inc. All Rights Reserved.
 
2
 
 
3
#include "s1angle.h"
 
4
 
 
5
#include <sstream>
 
6
 
 
7
#include "base/commandlineflags.h"
 
8
#include "base/integral_types.h"
 
9
#include "base/logging.h"
 
10
#include "gtest/gtest.h"
 
11
#include "s2latlng.h"
 
12
#include "s2testing.h"
 
13
 
 
14
using namespace std;
 
15
 
 
16
DEFINE_int32(iters, (DEBUG_MODE ? 100 : 1000) * (1000 * 1000),
 
17
             "Run timing tests with this many iterations");
 
18
 
 
19
TEST(S1Angle, DefaultConstructor) {
 
20
  // Check that the default constructor returns an angle of 0.
 
21
  S1Angle a;
 
22
  EXPECT_EQ(0, a.radians());
 
23
}
 
24
 
 
25
TEST(S1Angle, PiRadiansExactly180Degrees) {
 
26
  // Check that the conversion between Pi radians and 180 degrees is exact.
 
27
  EXPECT_EQ(M_PI, S1Angle::Radians(M_PI).radians());
 
28
  EXPECT_EQ(180.0, S1Angle::Radians(M_PI).degrees());
 
29
  EXPECT_EQ(M_PI, S1Angle::Degrees(180).radians());
 
30
  EXPECT_EQ(180.0, S1Angle::Degrees(180).degrees());
 
31
 
 
32
  EXPECT_EQ(90.0, S1Angle::Radians(M_PI_2).degrees());
 
33
 
 
34
  // Check negative angles.
 
35
  EXPECT_EQ(-90.0, S1Angle::Radians(-M_PI_2).degrees());
 
36
  EXPECT_EQ(-M_PI_4, S1Angle::Degrees(-45).radians());
 
37
}
 
38
 
 
39
TEST(S1Angle, E5E6E7Representations) {
 
40
  // Check that E5/E6/E7 representations work as expected.
 
41
  EXPECT_DOUBLE_EQ(S1Angle::Degrees(-45).radians(),
 
42
                   S1Angle::E5(-4500000).radians());
 
43
  EXPECT_DOUBLE_EQ(S1Angle::Degrees(-60).radians(),
 
44
                   S1Angle::E6(-60000000).radians());
 
45
  EXPECT_DOUBLE_EQ(S1Angle::Degrees(75).radians(),
 
46
                   S1Angle::E7(750000000).radians());
 
47
  EXPECT_EQ(-17256123, S1Angle::Degrees(-172.56123).e5());
 
48
  EXPECT_EQ(12345678, S1Angle::Degrees(12.345678).e6());
 
49
  EXPECT_EQ(-123456789, S1Angle::Degrees(-12.3456789).e7());
 
50
}
 
51
 
 
52
TEST(S1Angle, E6E7RepresentationsUnsigned) {
 
53
  // Check that unsigned E6/E7 representations work as expected.
 
54
  EXPECT_DOUBLE_EQ(
 
55
      S1Angle::Degrees(60).radians(),
 
56
      S1Angle::UnsignedE6(static_cast<uint32>(60000000)).radians());
 
57
  EXPECT_DOUBLE_EQ(
 
58
      S1Angle::Degrees(-60).radians(),
 
59
      S1Angle::UnsignedE6(static_cast<uint32>(-60000000)).radians());
 
60
  EXPECT_DOUBLE_EQ(
 
61
      S1Angle::Degrees(75).radians(),
 
62
      S1Angle::UnsignedE7(static_cast<uint32>(750000000)).radians());
 
63
  EXPECT_DOUBLE_EQ(
 
64
      S1Angle::Degrees(-75).radians(),
 
65
      S1Angle::UnsignedE7(static_cast<uint32>(-750000000)).radians());
 
66
}
 
67
 
 
68
TEST(S1Angle, NormalizeCorrectlyCanonicalizesAngles) {
 
69
  EXPECT_DOUBLE_EQ(0.0, S1Angle::Degrees(360.0).Normalized().degrees());
 
70
  EXPECT_DOUBLE_EQ(180.0, S1Angle::Degrees(-180.0).Normalized().degrees());
 
71
  EXPECT_DOUBLE_EQ(180.0, S1Angle::Degrees(180.0).Normalized().degrees());
 
72
  EXPECT_DOUBLE_EQ(180.0, S1Angle::Degrees(540.0).Normalized().degrees());
 
73
  EXPECT_DOUBLE_EQ(90.0, S1Angle::Degrees(-270.0).Normalized().degrees());
 
74
}
 
75
 
 
76
TEST(S1Angle, ArithmeticOperationsOnAngles) {
 
77
  EXPECT_DOUBLE_EQ(0.3, S1Angle::Radians(-0.3).abs().radians());
 
78
  EXPECT_DOUBLE_EQ(-0.1, (-S1Angle::Radians(0.1)).radians());
 
79
  EXPECT_DOUBLE_EQ(0.4,
 
80
                   (S1Angle::Radians(0.1) + S1Angle::Radians(0.3)).radians());
 
81
  EXPECT_DOUBLE_EQ(-0.2,
 
82
                   (S1Angle::Radians(0.1) - S1Angle::Radians(0.3)).radians());
 
83
  EXPECT_DOUBLE_EQ(0.6, (2 * S1Angle::Radians(0.3)).radians());
 
84
  EXPECT_DOUBLE_EQ(0.6, (S1Angle::Radians(0.3) * 2).radians());
 
85
  EXPECT_DOUBLE_EQ(0.15, (S1Angle::Radians(0.3) / 2).radians());
 
86
  EXPECT_DOUBLE_EQ(0.5, (S1Angle::Radians(0.3) / S1Angle::Radians(0.6)));
 
87
 
 
88
  S1Angle tmp = S1Angle::Radians(1.0);
 
89
  tmp += S1Angle::Radians(0.5);
 
90
  EXPECT_DOUBLE_EQ(1.5, tmp.radians());
 
91
  tmp -= S1Angle::Radians(1.0);
 
92
  EXPECT_DOUBLE_EQ(0.5, tmp.radians());
 
93
  tmp *= 5;
 
94
  EXPECT_DOUBLE_EQ(2.5, tmp.radians());
 
95
  tmp /= 2;
 
96
  EXPECT_DOUBLE_EQ(1.25, tmp.radians());
 
97
}
 
98
 
 
99
TEST(S1Angle, ConstructorsThatMeasureAngles) {
 
100
  EXPECT_DOUBLE_EQ(M_PI_2,
 
101
                   S1Angle(S2Point(1, 0, 0), S2Point(0, 0, 2)).radians());
 
102
  EXPECT_DOUBLE_EQ(0.0, S1Angle(S2Point(1, 0, 0), S2Point(1, 0, 0)).radians());
 
103
  EXPECT_NEAR(50.0,
 
104
              S1Angle(S2LatLng::FromDegrees(20, 20),
 
105
                      S2LatLng::FromDegrees(70, 20)).degrees(),
 
106
              1e-13);
 
107
}
 
108
 
 
109
TEST(S1Angle, TestFormatting) {
 
110
  ostringstream ss;
 
111
  ss << S1Angle::Degrees(180.0);
 
112
  EXPECT_EQ("180.0000000", ss.str());
 
113
}
 
114
 
 
115
TEST(S1Angle, TestPerformance) {
 
116
  // Verify that the conversion to E5/E6/E7 is not much slower than the
 
117
  // conversion from E5/E6/E7.  (Float-to-integer conversions can be quite
 
118
  // slow on some platforms.)  We only check the times for E6; the times for
 
119
  // E5/E7 should be similar.
 
120
 
 
121
  // To reduce the impact of loop overhead, we do kOpsPerLoop ops per loop.
 
122
  static const int kOpsPerLoop = 8;
 
123
 
 
124
  // Time conversion from E6 to radians.
 
125
  double rad_sum = 0;
 
126
  const double from_e6_start = S2Testing::GetCpuTime();
 
127
  for (int i = FLAGS_iters; i > 0; i -= kOpsPerLoop) {
 
128
    // We structure both loops so that all the conversions can be done in
 
129
    // parallel.  Otherwise on some platforms the optimizer happens to do a
 
130
    // much better job of parallelizing one loop than the other.
 
131
    double r0 = S1Angle::E6(i-0).radians();
 
132
    double r1 = S1Angle::E6(i-1).radians();
 
133
    double r2 = S1Angle::E6(i-2).radians();
 
134
    double r3 = S1Angle::E6(i-3).radians();
 
135
    double r4 = S1Angle::E6(i-4).radians();
 
136
    double r5 = S1Angle::E6(i-5).radians();
 
137
    double r6 = S1Angle::E6(i-6).radians();
 
138
    double r7 = S1Angle::E6(i-7).radians();
 
139
    rad_sum += ((r0 + r1) + (r2 + r3)) + ((r4 + r5) + (r6 + r7));
 
140
  }
 
141
  const double from_e6_time = S2Testing::GetCpuTime() - from_e6_start;
 
142
  EXPECT_NE(rad_sum, 0);  // Don't let the sum get optimized away.
 
143
  LOG(INFO) << "From E6: "
 
144
            << (FLAGS_iters / from_e6_time)
 
145
            << " values per second";
 
146
 
 
147
  // Time conversion from radians to E6.
 
148
  const double delta = (2 * M_PI) / (FLAGS_iters - 1);
 
149
  double angle = -M_PI;
 
150
  long e6_sum = 0;
 
151
  const double to_e6_start = S2Testing::GetCpuTime();
 
152
  for (int i = FLAGS_iters; i > 0; i -= kOpsPerLoop) {
 
153
    long r0 = S1Angle::Radians(angle).e6(); angle += delta;
 
154
    long r1 = S1Angle::Radians(angle).e6(); angle += delta;
 
155
    long r2 = S1Angle::Radians(angle).e6(); angle += delta;
 
156
    long r3 = S1Angle::Radians(angle).e6(); angle += delta;
 
157
    long r4 = S1Angle::Radians(angle).e6(); angle += delta;
 
158
    long r5 = S1Angle::Radians(angle).e6(); angle += delta;
 
159
    long r6 = S1Angle::Radians(angle).e6(); angle += delta;
 
160
    long r7 = S1Angle::Radians(angle).e6(); angle += delta;
 
161
    e6_sum += ((r0 + r1) + (r2 + r3)) + ((r4 + r5) + (r6 + r7));
 
162
  }
 
163
  const double to_e6_time = S2Testing::GetCpuTime() - to_e6_start;
 
164
  EXPECT_NE(e6_sum + angle, 0);  // Don't let them get optimized away.
 
165
  LOG(INFO) << "  To E6: "
 
166
            << (FLAGS_iters / to_e6_time)
 
167
            << " values per second";
 
168
 
 
169
  // Make sure that the To/From E6 times are not much different.
 
170
  // The difference factor slightly less than 2 on an x86_64.
 
171
  EXPECT_LE(from_e6_time / to_e6_time, 3);
 
172
  EXPECT_LE(to_e6_time / from_e6_time, 3);
 
173
}