mojo/services/files/public/c/tests/mojio_unistd_unittest.cc - Issue 1388413005: Move //mojo/services/X/public/... to //mojo/services/X/... (part 1).

Side by Side Diff: mojo/services/files/public/c/tests/mojio_unistd_unittest.cc

Issue 1388413005: Move //mojo/services/X/public/... to //mojo/services/X/... (part 1). (Closed) Base URL: https://github.com/domokit/mojo.git@master

Patch Set: Created 5 years, 2 months ago

Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.

Jump to:

View unified diff | Download patch

OLD	NEW
	(Empty)
1 // Copyright 2015 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 // Basic tests of things declared in mojio_unistd.h, as well as

6 // \|mojio_creat()\|/\|mojio_open()\| from mojio_fcntl.h. Note that more thorough

7 // tests are done more directly at a different level.

8

9 #include <errno.h>

10 #include <string.h>

11

12 #include "files/public/c/mojio_fcntl.h"

13 #include "files/public/c/mojio_sys_stat.h"

14 #include "files/public/c/mojio_unistd.h"

15 #include "files/public/c/tests/mojio_test_base.h"

16

17 namespace {

18

19 using MojioUnistdTest = mojio::test::MojioTestBase;

20

21 TEST_F(MojioUnistdTest, CreatWriteOpenCloseReadClose) {

22 const char kTestFileName[] = "test_file";

23 const char kTestData[] = "Hello mojio!";

24

25 errno = 12345;

26 int write_fd = mojio_creat(kTestFileName, MOJIO_S_IRWXU);

27 int errno_value = errno; // \|ASSERT_EQ()\| might conceivably change errno.

28 ASSERT_EQ(0, write_fd); // FDs are allocated starting from 0.

29 EXPECT_EQ(12345, errno_value); // errno should be untouched.

30

31 errno = 12345;

32 mojio_ssize_t bytes_written =

33 mojio_write(write_fd, kTestData, sizeof(kTestData));

34 errno_value = errno;

35 EXPECT_EQ(static_cast<mojio_ssize_t>(sizeof(kTestData)), bytes_written);

36 EXPECT_EQ(12345, errno_value);

37

38 errno = 12345;

39 int read_fd = mojio_open(kTestFileName, MOJIO_O_RDONLY);

40 errno_value = errno;

41 ASSERT_EQ(1, read_fd); // \|write_fd\| is still open, so we should get 1.

42 EXPECT_EQ(12345, errno_value);

43

44 errno = 12345;

45 int result = mojio_close(write_fd);

46 errno_value = errno;

47 EXPECT_EQ(0, result);

48 EXPECT_EQ(12345, errno_value);

49

50 char buffer[100] = {};

51 errno = 12345;

52 mojio_ssize_t bytes_read = mojio_read(read_fd, buffer, sizeof(buffer));

53 errno_value = errno;

54 EXPECT_EQ(static_cast<mojio_ssize_t>(sizeof(kTestData)), bytes_read);

55 EXPECT_EQ(12345, errno_value);

56 EXPECT_EQ(0, memcmp(buffer, kTestData, sizeof(kTestData)));

57 EXPECT_EQ('\0', buffer[sizeof(kTestData)]);

58

59 errno = 12345;

60 result = mojio_close(read_fd);

61 errno_value = errno;

62 EXPECT_EQ(0, result);

63 EXPECT_EQ(12345, errno_value);

64 }

65

66 TEST_F(MojioUnistdTest, FtruncateLseek) {

67 const char kTestData[] = "Hello mojio!";

68

69 int fd = mojio_open("my_file", MOJIO_O_CREAT \| MOJIO_O_RDWR, MOJIO_S_IRWXU);

70 EXPECT_GE(fd, 0);

71

72 mojio_ssize_t bytes_written = mojio_write(fd, kTestData, sizeof(kTestData));

73 EXPECT_EQ(static_cast<mojio_ssize_t>(sizeof(kTestData)), bytes_written);

74

75 errno = 12345;

76 int result = mojio_ftruncate(fd, sizeof(kTestData) - 2);

77 int errno_value = errno;

78 EXPECT_EQ(0, result);

79 EXPECT_EQ(12345, errno_value);

80

81 errno = 12345;

82 mojio_off_t offset = mojio_lseek(fd, -5, MOJIO_SEEK_END);

83 errno_value = errno;

84 EXPECT_EQ(static_cast<mojio_off_t>(sizeof(kTestData)) - 2 - 5, offset);

85 EXPECT_EQ(12345, errno_value);

86

87 char buffer[100] = {};

88 errno = 12345;

89 mojio_ssize_t bytes_read = mojio_read(fd, buffer, sizeof(buffer));

90 errno_value = errno;

91 EXPECT_EQ(5, bytes_read);

92 EXPECT_EQ(12345, errno_value);

93 EXPECT_EQ(0, memcmp(buffer, &kTestData[sizeof(kTestData) - 2 - 5], 5));

94 EXPECT_EQ('\0', buffer[5]);

95

96 EXPECT_EQ(0, mojio_close(fd));

97 }

98

99 TEST_F(MojioUnistdTest, Ebadf) {

100 errno = 12345;

101 int result = mojio_close(-1);

102 int errno_value = errno;

103 EXPECT_EQ(-1, result);

104 EXPECT_EQ(EBADF, errno_value);

105

106 errno = 12345;

107 result = mojio_dup(-1);

108 errno_value = errno;

109 EXPECT_EQ(-1, result);

110 EXPECT_EQ(EBADF, errno_value);

111

112 errno = 12345;

113 result = mojio_ftruncate(-1, 0);

114 errno_value = errno;

115 EXPECT_EQ(-1, result);

116 EXPECT_EQ(EBADF, errno_value);

117

118 errno = 12345;

119 mojio_off_t offset = mojio_lseek(-1, 0, MOJIO_SEEK_SET);

120 errno_value = errno;

121 EXPECT_EQ(-1, offset);

122 EXPECT_EQ(EBADF, errno_value);

123

124 char buf[10] = {};

125 errno = 12345;

126 mojio_ssize_t size = mojio_read(-1, buf, sizeof(buf));

127 errno_value = errno;

128 EXPECT_EQ(-1, size);

129 EXPECT_EQ(EBADF, errno_value);

130

131 errno = 12345;

132 size = mojio_write(-1, buf, sizeof(buf));

133 errno_value = errno;

134 EXPECT_EQ(-1, size);

135 EXPECT_EQ(EBADF, errno_value);

136 }

137

138 // TODO(vtl): mojio_chdir(), mojio_dup().

139

140 } // namespace

OLD	NEW