Page Menu
Home
c4science
Search
Configure Global Search
Log In
Files
F73209691
googletest-tuple-test.cc
No One
Temporary
Actions
Download File
Edit File
Delete File
View Transforms
Subscribe
Mute Notifications
Award Token
Subscribers
None
File Metadata
Details
File Info
Storage
Attached
Created
Fri, Jul 19, 15:21
Size
8 KB
Mime Type
text/x-c
Expires
Sun, Jul 21, 15:21 (1 d, 21 h)
Engine
blob
Format
Raw Data
Handle
19160606
Attached To
R9484 sp4e-homework-lars-bertil
googletest-tuple-test.cc
View Options
// Copyright 2007, Google Inc.
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are
// met:
//
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above
// copyright notice, this list of conditions and the following disclaimer
// in the documentation and/or other materials provided with the
// distribution.
// * Neither the name of Google Inc. nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "gtest/internal/gtest-tuple.h"
#include <utility>
#include "gtest/gtest.h"
namespace
{
using
::
std
::
tr1
::
get
;
using
::
std
::
tr1
::
make_tuple
;
using
::
std
::
tr1
::
tuple
;
using
::
std
::
tr1
::
tuple_element
;
using
::
std
::
tr1
::
tuple_size
;
using
::
testing
::
StaticAssertTypeEq
;
// Tests that tuple_element<K, tuple<T0, T1, ..., TN> >::type returns TK.
TEST
(
tuple_element_Test
,
ReturnsElementType
)
{
StaticAssertTypeEq
<
int
,
tuple_element
<
0
,
tuple
<
int
,
char
>
>::
type
>
();
StaticAssertTypeEq
<
int
&
,
tuple_element
<
1
,
tuple
<
double
,
int
&>
>::
type
>
();
StaticAssertTypeEq
<
bool
,
tuple_element
<
2
,
tuple
<
double
,
int
,
bool
>
>::
type
>
();
}
// Tests that tuple_size<T>::value gives the number of fields in tuple
// type T.
TEST
(
tuple_size_Test
,
ReturnsNumberOfFields
)
{
EXPECT_EQ
(
0
,
+
tuple_size
<
tuple
<>
>::
value
);
EXPECT_EQ
(
1
,
+
tuple_size
<
tuple
<
void
*>
>::
value
);
EXPECT_EQ
(
1
,
+
tuple_size
<
tuple
<
char
>
>::
value
);
EXPECT_EQ
(
1
,
+
(
tuple_size
<
tuple
<
tuple
<
int
,
double
>
>
>::
value
));
EXPECT_EQ
(
2
,
+
(
tuple_size
<
tuple
<
int
&
,
const
char
>
>::
value
));
EXPECT_EQ
(
3
,
+
(
tuple_size
<
tuple
<
char
*
,
void
,
const
bool
&>
>::
value
));
}
// Tests comparing a tuple with itself.
TEST
(
ComparisonTest
,
ComparesWithSelf
)
{
const
tuple
<
int
,
char
,
bool
>
a
(
5
,
'a'
,
false
);
EXPECT_TRUE
(
a
==
a
);
EXPECT_FALSE
(
a
!=
a
);
}
// Tests comparing two tuples with the same value.
TEST
(
ComparisonTest
,
ComparesEqualTuples
)
{
const
tuple
<
int
,
bool
>
a
(
5
,
true
),
b
(
5
,
true
);
EXPECT_TRUE
(
a
==
b
);
EXPECT_FALSE
(
a
!=
b
);
}
// Tests comparing two different tuples that have no reference fields.
TEST
(
ComparisonTest
,
ComparesUnequalTuplesWithoutReferenceFields
)
{
typedef
tuple
<
const
int
,
char
>
FooTuple
;
const
FooTuple
a
(
0
,
'x'
);
const
FooTuple
b
(
1
,
'a'
);
EXPECT_TRUE
(
a
!=
b
);
EXPECT_FALSE
(
a
==
b
);
const
FooTuple
c
(
1
,
'b'
);
EXPECT_TRUE
(
b
!=
c
);
EXPECT_FALSE
(
b
==
c
);
}
// Tests comparing two different tuples that have reference fields.
TEST
(
ComparisonTest
,
ComparesUnequalTuplesWithReferenceFields
)
{
typedef
tuple
<
int
&
,
const
char
&>
FooTuple
;
int
i
=
5
;
const
char
ch
=
'a'
;
const
FooTuple
a
(
i
,
ch
);
int
j
=
6
;
const
FooTuple
b
(
j
,
ch
);
EXPECT_TRUE
(
a
!=
b
);
EXPECT_FALSE
(
a
==
b
);
j
=
5
;
const
char
ch2
=
'b'
;
const
FooTuple
c
(
j
,
ch2
);
EXPECT_TRUE
(
b
!=
c
);
EXPECT_FALSE
(
b
==
c
);
}
// Tests that a tuple field with a reference type is an alias of the
// variable it's supposed to reference.
TEST
(
ReferenceFieldTest
,
IsAliasOfReferencedVariable
)
{
int
n
=
0
;
tuple
<
bool
,
int
&>
t
(
true
,
n
);
n
=
1
;
EXPECT_EQ
(
n
,
get
<
1
>
(
t
))
<<
"Changing a underlying variable should update the reference field."
;
// Makes sure that the implementation doesn't do anything funny with
// the & operator for the return type of get<>().
EXPECT_EQ
(
&
n
,
&
(
get
<
1
>
(
t
)))
<<
"The address of a reference field should equal the address of "
<<
"the underlying variable."
;
get
<
1
>
(
t
)
=
2
;
EXPECT_EQ
(
2
,
n
)
<<
"Changing a reference field should update the underlying variable."
;
}
// Tests that tuple's default constructor default initializes each field.
// This test needs to compile without generating warnings.
TEST
(
TupleConstructorTest
,
DefaultConstructorDefaultInitializesEachField
)
{
// The TR1 report requires that tuple's default constructor default
// initializes each field, even if it's a primitive type. If the
// implementation forgets to do this, this test will catch it by
// generating warnings about using uninitialized variables (assuming
// a decent compiler).
tuple
<>
empty
;
tuple
<
int
>
a1
,
b1
;
b1
=
a1
;
EXPECT_EQ
(
0
,
get
<
0
>
(
b1
));
tuple
<
int
,
double
>
a2
,
b2
;
b2
=
a2
;
EXPECT_EQ
(
0
,
get
<
0
>
(
b2
));
EXPECT_EQ
(
0.0
,
get
<
1
>
(
b2
));
tuple
<
double
,
char
,
bool
*>
a3
,
b3
;
b3
=
a3
;
EXPECT_EQ
(
0.0
,
get
<
0
>
(
b3
));
EXPECT_EQ
(
'\0'
,
get
<
1
>
(
b3
));
EXPECT_TRUE
(
get
<
2
>
(
b3
)
==
NULL
);
tuple
<
int
,
int
,
int
,
int
,
int
,
int
,
int
,
int
,
int
,
int
>
a10
,
b10
;
b10
=
a10
;
EXPECT_EQ
(
0
,
get
<
0
>
(
b10
));
EXPECT_EQ
(
0
,
get
<
1
>
(
b10
));
EXPECT_EQ
(
0
,
get
<
2
>
(
b10
));
EXPECT_EQ
(
0
,
get
<
3
>
(
b10
));
EXPECT_EQ
(
0
,
get
<
4
>
(
b10
));
EXPECT_EQ
(
0
,
get
<
5
>
(
b10
));
EXPECT_EQ
(
0
,
get
<
6
>
(
b10
));
EXPECT_EQ
(
0
,
get
<
7
>
(
b10
));
EXPECT_EQ
(
0
,
get
<
8
>
(
b10
));
EXPECT_EQ
(
0
,
get
<
9
>
(
b10
));
}
// Tests constructing a tuple from its fields.
TEST
(
TupleConstructorTest
,
ConstructsFromFields
)
{
int
n
=
1
;
// Reference field.
tuple
<
int
&>
a
(
n
);
EXPECT_EQ
(
&
n
,
&
(
get
<
0
>
(
a
)));
// Non-reference fields.
tuple
<
int
,
char
>
b
(
5
,
'a'
);
EXPECT_EQ
(
5
,
get
<
0
>
(
b
));
EXPECT_EQ
(
'a'
,
get
<
1
>
(
b
));
// Const reference field.
const
int
m
=
2
;
tuple
<
bool
,
const
int
&>
c
(
true
,
m
);
EXPECT_TRUE
(
get
<
0
>
(
c
));
EXPECT_EQ
(
&
m
,
&
(
get
<
1
>
(
c
)));
}
// Tests tuple's copy constructor.
TEST
(
TupleConstructorTest
,
CopyConstructor
)
{
tuple
<
double
,
bool
>
a
(
0.0
,
true
);
tuple
<
double
,
bool
>
b
(
a
);
EXPECT_DOUBLE_EQ
(
0.0
,
get
<
0
>
(
b
));
EXPECT_TRUE
(
get
<
1
>
(
b
));
}
// Tests constructing a tuple from another tuple that has a compatible
// but different type.
TEST
(
TupleConstructorTest
,
ConstructsFromDifferentTupleType
)
{
tuple
<
int
,
int
,
char
>
a
(
0
,
1
,
'a'
);
tuple
<
double
,
long
,
int
>
b
(
a
);
EXPECT_DOUBLE_EQ
(
0.0
,
get
<
0
>
(
b
));
EXPECT_EQ
(
1
,
get
<
1
>
(
b
));
EXPECT_EQ
(
'a'
,
get
<
2
>
(
b
));
}
// Tests constructing a 2-tuple from an std::pair.
TEST
(
TupleConstructorTest
,
ConstructsFromPair
)
{
::
std
::
pair
<
int
,
char
>
a
(
1
,
'a'
);
tuple
<
int
,
char
>
b
(
a
);
tuple
<
int
,
const
char
&>
c
(
a
);
}
// Tests assigning a tuple to another tuple with the same type.
TEST
(
TupleAssignmentTest
,
AssignsToSameTupleType
)
{
const
tuple
<
int
,
long
>
a
(
5
,
7L
);
tuple
<
int
,
long
>
b
;
b
=
a
;
EXPECT_EQ
(
5
,
get
<
0
>
(
b
));
EXPECT_EQ
(
7L
,
get
<
1
>
(
b
));
}
// Tests assigning a tuple to another tuple with a different but
// compatible type.
TEST
(
TupleAssignmentTest
,
AssignsToDifferentTupleType
)
{
const
tuple
<
int
,
long
,
bool
>
a
(
1
,
7L
,
true
);
tuple
<
long
,
int
,
bool
>
b
;
b
=
a
;
EXPECT_EQ
(
1L
,
get
<
0
>
(
b
));
EXPECT_EQ
(
7
,
get
<
1
>
(
b
));
EXPECT_TRUE
(
get
<
2
>
(
b
));
}
// Tests assigning an std::pair to a 2-tuple.
TEST
(
TupleAssignmentTest
,
AssignsFromPair
)
{
const
::
std
::
pair
<
int
,
bool
>
a
(
5
,
true
);
tuple
<
int
,
bool
>
b
;
b
=
a
;
EXPECT_EQ
(
5
,
get
<
0
>
(
b
));
EXPECT_TRUE
(
get
<
1
>
(
b
));
tuple
<
long
,
bool
>
c
;
c
=
a
;
EXPECT_EQ
(
5L
,
get
<
0
>
(
c
));
EXPECT_TRUE
(
get
<
1
>
(
c
));
}
// A fixture for testing big tuples.
class
BigTupleTest
:
public
testing
::
Test
{
protected
:
typedef
tuple
<
int
,
int
,
int
,
int
,
int
,
int
,
int
,
int
,
int
,
int
>
BigTuple
;
BigTupleTest
()
:
a_
(
1
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
2
),
b_
(
1
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
0
,
3
)
{}
BigTuple
a_
,
b_
;
};
// Tests constructing big tuples.
TEST_F
(
BigTupleTest
,
Construction
)
{
BigTuple
a
;
BigTuple
b
(
b_
);
}
// Tests that get<N>(t) returns the N-th (0-based) field of tuple t.
TEST_F
(
BigTupleTest
,
get
)
{
EXPECT_EQ
(
1
,
get
<
0
>
(
a_
));
EXPECT_EQ
(
2
,
get
<
9
>
(
a_
));
// Tests that get() works on a const tuple too.
const
BigTuple
a
(
a_
);
EXPECT_EQ
(
1
,
get
<
0
>
(
a
));
EXPECT_EQ
(
2
,
get
<
9
>
(
a
));
}
// Tests comparing big tuples.
TEST_F
(
BigTupleTest
,
Comparisons
)
{
EXPECT_TRUE
(
a_
==
a_
);
EXPECT_FALSE
(
a_
!=
a_
);
EXPECT_TRUE
(
a_
!=
b_
);
EXPECT_FALSE
(
a_
==
b_
);
}
TEST
(
MakeTupleTest
,
WorksForScalarTypes
)
{
tuple
<
bool
,
int
>
a
;
a
=
make_tuple
(
true
,
5
);
EXPECT_TRUE
(
get
<
0
>
(
a
));
EXPECT_EQ
(
5
,
get
<
1
>
(
a
));
tuple
<
char
,
int
,
long
>
b
;
b
=
make_tuple
(
'a'
,
'b'
,
5
);
EXPECT_EQ
(
'a'
,
get
<
0
>
(
b
));
EXPECT_EQ
(
'b'
,
get
<
1
>
(
b
));
EXPECT_EQ
(
5
,
get
<
2
>
(
b
));
}
TEST
(
MakeTupleTest
,
WorksForPointers
)
{
int
a
[]
=
{
1
,
2
,
3
,
4
};
const
char
*
const
str
=
"hi"
;
int
*
const
p
=
a
;
tuple
<
const
char
*
,
int
*>
t
;
t
=
make_tuple
(
str
,
p
);
EXPECT_EQ
(
str
,
get
<
0
>
(
t
));
EXPECT_EQ
(
p
,
get
<
1
>
(
t
));
}
}
// namespace
Event Timeline
Log In to Comment