summaryrefslogtreecommitdiffstats
path: root/samples
diff options
context:
space:
mode:
Diffstat (limited to 'samples')
-rw-r--r--samples/sample2.cc14
-rw-r--r--samples/sample2.h12
-rw-r--r--samples/sample2_unittest.cc2
-rw-r--r--samples/sample3-inl.h50
-rw-r--r--samples/sample3_unittest.cc6
-rw-r--r--samples/sample5_unittest.cc8
6 files changed, 46 insertions, 46 deletions
diff --git a/samples/sample2.cc b/samples/sample2.cc
index 53857c0..5f763b9 100644
--- a/samples/sample2.cc
+++ b/samples/sample2.cc
@@ -36,21 +36,21 @@
#include <string.h>
// Clones a 0-terminated C string, allocating memory using new.
-const char * MyString::CloneCString(const char * c_string) {
- if (c_string == NULL) return NULL;
+const char* MyString::CloneCString(const char* a_c_string) {
+ if (a_c_string == NULL) return NULL;
- const size_t len = strlen(c_string);
- char * const clone = new char[ len + 1 ];
- memcpy(clone, c_string, len + 1);
+ const size_t len = strlen(a_c_string);
+ char* const clone = new char[ len + 1 ];
+ memcpy(clone, a_c_string, len + 1);
return clone;
}
// Sets the 0-terminated C string this MyString object
// represents.
-void MyString::Set(const char * c_string) {
+void MyString::Set(const char* a_c_string) {
// Makes sure this works when c_string == c_string_
- const char * const temp = MyString::CloneCString(c_string);
+ const char* const temp = MyString::CloneCString(a_c_string);
delete[] c_string_;
c_string_ = temp;
}
diff --git a/samples/sample2.h b/samples/sample2.h
index c5f3b8c..5b57e60 100644
--- a/samples/sample2.h
+++ b/samples/sample2.h
@@ -40,13 +40,13 @@
// A simple string class.
class MyString {
private:
- const char * c_string_;
+ const char* c_string_;
const MyString& operator=(const MyString& rhs);
public:
// Clones a 0-terminated C string, allocating memory using new.
- static const char * CloneCString(const char * c_string);
+ static const char* CloneCString(const char* a_c_string);
////////////////////////////////////////////////////////////
//
@@ -56,8 +56,8 @@ class MyString {
MyString() : c_string_(NULL) {}
// Constructs a MyString by cloning a 0-terminated C string.
- explicit MyString(const char * c_string) : c_string_(NULL) {
- Set(c_string);
+ explicit MyString(const char* a_c_string) : c_string_(NULL) {
+ Set(a_c_string);
}
// Copy c'tor
@@ -72,14 +72,14 @@ class MyString {
~MyString() { delete[] c_string_; }
// Gets the 0-terminated C string this MyString object represents.
- const char * c_string() const { return c_string_; }
+ const char* c_string() const { return c_string_; }
size_t Length() const {
return c_string_ == NULL ? 0 : strlen(c_string_);
}
// Sets the 0-terminated C string this MyString object represents.
- void Set(const char * c_string);
+ void Set(const char* c_string);
};
diff --git a/samples/sample2_unittest.cc b/samples/sample2_unittest.cc
index e1d7910..32232d9 100644
--- a/samples/sample2_unittest.cc
+++ b/samples/sample2_unittest.cc
@@ -71,7 +71,7 @@ TEST(MyString, DefaultConstructor) {
// </TechnicalDetails>
EXPECT_STREQ(NULL, s.c_string());
- EXPECT_EQ(0, s.Length());
+ EXPECT_EQ(0u, s.Length());
}
const char kHelloString[] = "Hello, world!";
diff --git a/samples/sample3-inl.h b/samples/sample3-inl.h
index 630e950..46369a0 100644
--- a/samples/sample3-inl.h
+++ b/samples/sample3-inl.h
@@ -51,23 +51,23 @@ class QueueNode {
public:
// Gets the element in this node.
- const E & element() const { return element_; }
+ const E& element() const { return element_; }
// Gets the next node in the queue.
- QueueNode * next() { return next_; }
- const QueueNode * next() const { return next_; }
+ QueueNode* next() { return next_; }
+ const QueueNode* next() const { return next_; }
private:
// Creates a node with a given element value. The next pointer is
// set to NULL.
- QueueNode(const E & element) : element_(element), next_(NULL) {}
+ QueueNode(const E& an_element) : element_(an_element), next_(NULL) {}
// We disable the default assignment operator and copy c'tor.
- const QueueNode & operator = (const QueueNode &);
- QueueNode(const QueueNode &);
+ const QueueNode& operator = (const QueueNode&);
+ QueueNode(const QueueNode&);
E element_;
- QueueNode * next_;
+ QueueNode* next_;
};
template <typename E> // E is the element type.
@@ -84,8 +84,8 @@ public:
void Clear() {
if (size_ > 0) {
// 1. Deletes every node.
- QueueNode<E> * node = head_;
- QueueNode<E> * next = node->next();
+ QueueNode<E>* node = head_;
+ QueueNode<E>* next = node->next();
for (; ;) {
delete node;
node = next;
@@ -103,19 +103,19 @@ public:
size_t Size() const { return size_; }
// Gets the first element of the queue, or NULL if the queue is empty.
- QueueNode<E> * Head() { return head_; }
- const QueueNode<E> * Head() const { return head_; }
+ QueueNode<E>* Head() { return head_; }
+ const QueueNode<E>* Head() const { return head_; }
// Gets the last element of the queue, or NULL if the queue is empty.
- QueueNode<E> * Last() { return last_; }
- const QueueNode<E> * Last() const { return last_; }
+ QueueNode<E>* Last() { return last_; }
+ const QueueNode<E>* Last() const { return last_; }
// Adds an element to the end of the queue. A copy of the element is
// created using the copy constructor, and then stored in the queue.
// Changes made to the element in the queue doesn't affect the source
// object, and vice versa.
- void Enqueue(const E & element) {
- QueueNode<E> * new_node = new QueueNode<E>(element);
+ void Enqueue(const E& element) {
+ QueueNode<E>* new_node = new QueueNode<E>(element);
if (size_ == 0) {
head_ = last_ = new_node;
@@ -129,19 +129,19 @@ public:
// Removes the head of the queue and returns it. Returns NULL if
// the queue is empty.
- E * Dequeue() {
+ E* Dequeue() {
if (size_ == 0) {
return NULL;
}
- const QueueNode<E> * const old_head = head_;
+ const QueueNode<E>* const old_head = head_;
head_ = head_->next_;
size_--;
if (size_ == 0) {
last_ = NULL;
}
- E * element = new E(old_head->element());
+ E* element = new E(old_head->element());
delete old_head;
return element;
@@ -151,9 +151,9 @@ public:
// returns the result in a new queue. The original queue is not
// affected.
template <typename F>
- Queue * Map(F function) const {
- Queue * new_queue = new Queue();
- for (const QueueNode<E> * node = head_; node != NULL; node = node->next_) {
+ Queue* Map(F function) const {
+ Queue* new_queue = new Queue();
+ for (const QueueNode<E>* node = head_; node != NULL; node = node->next_) {
new_queue->Enqueue(function(node->element()));
}
@@ -161,13 +161,13 @@ public:
}
private:
- QueueNode<E> * head_; // The first node of the queue.
- QueueNode<E> * last_; // The last node of the queue.
+ QueueNode<E>* head_; // The first node of the queue.
+ QueueNode<E>* last_; // The last node of the queue.
size_t size_; // The number of elements in the queue.
// We disallow copying a queue.
- Queue(const Queue &);
- const Queue & operator = (const Queue &);
+ Queue(const Queue&);
+ const Queue& operator = (const Queue&);
};
#endif // GTEST_SAMPLES_SAMPLE3_INL_H_
diff --git a/samples/sample3_unittest.cc b/samples/sample3_unittest.cc
index a3d26da..34c1ca8 100644
--- a/samples/sample3_unittest.cc
+++ b/samples/sample3_unittest.cc
@@ -122,7 +122,7 @@ class QueueTest : public testing::Test {
// Tests the default c'tor.
TEST_F(QueueTest, DefaultConstructor) {
// You can access data in the test fixture here.
- EXPECT_EQ(0, q0_.Size());
+ EXPECT_EQ(0u, q0_.Size());
}
// Tests Dequeue().
@@ -133,13 +133,13 @@ TEST_F(QueueTest, Dequeue) {
n = q1_.Dequeue();
ASSERT_TRUE(n != NULL);
EXPECT_EQ(1, *n);
- EXPECT_EQ(0, q1_.Size());
+ EXPECT_EQ(0u, q1_.Size());
delete n;
n = q2_.Dequeue();
ASSERT_TRUE(n != NULL);
EXPECT_EQ(2, *n);
- EXPECT_EQ(1, q2_.Size());
+ EXPECT_EQ(1u, q2_.Size());
delete n;
}
diff --git a/samples/sample5_unittest.cc b/samples/sample5_unittest.cc
index be5df90..49dae7c 100644
--- a/samples/sample5_unittest.cc
+++ b/samples/sample5_unittest.cc
@@ -171,24 +171,24 @@ class QueueTest : public QuickTest {
// Tests the default constructor.
TEST_F(QueueTest, DefaultConstructor) {
- EXPECT_EQ(0, q0_.Size());
+ EXPECT_EQ(0u, q0_.Size());
}
// Tests Dequeue().
TEST_F(QueueTest, Dequeue) {
- int * n = q0_.Dequeue();
+ int* n = q0_.Dequeue();
EXPECT_TRUE(n == NULL);
n = q1_.Dequeue();
EXPECT_TRUE(n != NULL);
EXPECT_EQ(1, *n);
- EXPECT_EQ(0, q1_.Size());
+ EXPECT_EQ(0u, q1_.Size());
delete n;
n = q2_.Dequeue();
EXPECT_TRUE(n != NULL);
EXPECT_EQ(2, *n);
- EXPECT_EQ(1, q2_.Size());
+ EXPECT_EQ(1u, q2_.Size());
delete n;
}
generated by cgit v0.12 at 2024-10-31 19:50:03 (GMT)