Skip to content

Commit 42cb6eb

Browse files
batcheubatcheu
committed
[onert] Add MockSycallManager for customized system call mocking
It adds new MockSyscallsManager class to provide configurable hook system for mocking system calls in tests. ONE-DCO-1.0-Signed-off-by: Jonghwa Lee <[email protected]>
1 parent d84669e commit 42cb6eb

File tree

2 files changed

+250
-8
lines changed

2 files changed

+250
-8
lines changed

‎runtime/onert/backend/trix/ops/test/mock_syscalls.h‎

Lines changed: 123 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -21,13 +21,128 @@
2121
#include <sys/ioctl.h>
2222
#include <fcntl.h>
2323
#include <stdio.h>
24+
#include <functional>
25+
#include <memory>
26+
#include <cstdarg>
2427

25-
int open(const char *, int, ...) { return 0; }
26-
void *mmap(void *, size_t, int, int, int, off_t) { return (void *)0x1; }
27-
int munmap(void *, size_t) { return 0; }
28-
int close(int) { return 0; }
29-
int ioctl(int, unsigned long, ...) { return 0; }
30-
size_t fread(void *, size_t, size_t, FILE *) { return 1; }
31-
int fseek(FILE *, long, int) { return 0; }
28+
namespace onert
29+
{
30+
namespace backend
31+
{
32+
namespace trix
33+
{
34+
namespace ops
35+
{
36+
namespace test
37+
{
3238

33-
#endif
39+
class MockSyscallsManager
40+
{
41+
public:
42+
// Function type definitions for each syscall
43+
// Note: std::function doesn't work well with variadic functions, so we use specific signatures
44+
using OpenHook = std::function<int(const char *, int)>;
45+
using OpenCreatHook = std::function<int(const char *, int, mode_t)>;
46+
using MmapHook = std::function<void *(void *, size_t, int, int, int, off_t)>;
47+
using MunmapHook = std::function<int(void *, size_t)>;
48+
using CloseHook = std::function<int(int)>;
49+
using IoctlHook = std::function<int(int, unsigned long, void *)>;
50+
using FopenHook = std::function<FILE *(const char *, const char *)>;
51+
using FcloseHook = std::function<int(FILE *)>;
52+
using FreadHook = std::function<size_t(void *, size_t, size_t, FILE *)>;
53+
using FseekHook = std::function<int(FILE *, long, int)>;
54+
55+
static MockSyscallsManager &getInstance()
56+
{
57+
static MockSyscallsManager instance;
58+
return instance;
59+
}
60+
61+
// Hook registration functions
62+
void setOpenHook(OpenHook hook) { _openHook = hook; }
63+
void setOpenCreatHook(OpenCreatHook hook) { _openCreatHook = hook; }
64+
void setMmapHook(MmapHook hook) { _mmapHook = hook; }
65+
void setMunmapHook(MunmapHook hook) { _munmapHook = hook; }
66+
void setCloseHook(CloseHook hook) { _closeHook = hook; }
67+
void setIoctlHook(IoctlHook hook) { _ioctlHook = hook; }
68+
void setFopenHook(FopenHook hook) { _fopenHook = hook; }
69+
void setFcloseHook(FcloseHook hook) { _fcloseHook = hook; }
70+
void setFreadHook(FreadHook hook) { _freadHook = hook; }
71+
void setFseekHook(FseekHook hook) { _fseekHook = hook; }
72+
73+
// Hook retrieval functions
74+
OpenHook getOpenHook() const { return _openHook; }
75+
OpenCreatHook getOpenCreatHook() const { return _openCreatHook; }
76+
MmapHook getMmapHook() const { return _mmapHook; }
77+
MunmapHook getMunmapHook() const { return _munmapHook; }
78+
CloseHook getCloseHook() const { return _closeHook; }
79+
IoctlHook getIoctlHook() const { return _ioctlHook; }
80+
FopenHook getFopenHook() const { return _fopenHook; }
81+
FcloseHook getFcloseHook() const { return _fcloseHook; }
82+
FreadHook getFreadHook() const { return _freadHook; }
83+
FseekHook getFseekHook() const { return _fseekHook; }
84+
85+
// Hook clearing functions
86+
void clearOpenHook() { _openHook = nullptr; }
87+
void clearOpenCreatHook() { _openCreatHook = nullptr; }
88+
void clearMmapHook() { _mmapHook = nullptr; }
89+
void clearMunmapHook() { _munmapHook = nullptr; }
90+
void clearCloseHook() { _closeHook = nullptr; }
91+
void clearIoctlHook() { _ioctlHook = nullptr; }
92+
void clearFopenHook() { _fopenHook = nullptr; }
93+
void clearFcloseHook() { _fcloseHook = nullptr; }
94+
void clearFreadHook() { _freadHook = nullptr; }
95+
void clearFseekHook() { _fseekHook = nullptr; }
96+
97+
// Reset all hooks
98+
void resetAll()
99+
{
100+
clearOpenHook();
101+
clearOpenCreatHook();
102+
clearMmapHook();
103+
clearMunmapHook();
104+
clearCloseHook();
105+
clearIoctlHook();
106+
clearFopenHook();
107+
clearFcloseHook();
108+
clearFreadHook();
109+
clearFseekHook();
110+
}
111+
112+
private:
113+
MockSyscallsManager() = default;
114+
~MockSyscallsManager() = default;
115+
MockSyscallsManager(const MockSyscallsManager &) = delete;
116+
MockSyscallsManager &operator=(const MockSyscallsManager &) = delete;
117+
118+
// Hook function pointers
119+
OpenHook _openHook;
120+
OpenCreatHook _openCreatHook;
121+
MmapHook _mmapHook;
122+
MunmapHook _munmapHook;
123+
CloseHook _closeHook;
124+
IoctlHook _ioctlHook;
125+
FopenHook _fopenHook;
126+
FcloseHook _fcloseHook;
127+
FreadHook _freadHook;
128+
FseekHook _fseekHook;
129+
};
130+
131+
} // namespace test
132+
} // namespace ops
133+
} // namespace trix
134+
} // namespace backend
135+
} // namespace onert
136+
137+
// Mock syscall implementations
138+
int open(const char *pathname, int flags, ...);
139+
void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset);
140+
int munmap(void *addr, size_t length);
141+
int close(int fd);
142+
int ioctl(int fd, unsigned long request, ...);
143+
FILE *fopen(const char *path, const char *mode);
144+
int fclose(FILE *stream);
145+
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream);
146+
int fseek(FILE *stream, long offset, int whence);
147+
148+
#endif // _MOCK_SYSCALLS_H_

‎runtime/onert/backend/trix/ops/test/mock_syscalls.test.cc‎

Lines changed: 127 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,127 @@
1+
/*
2+
* Copyright (c) 2025 Samsung Electronics Co., Ltd. All Rights Reserved
3+
*
4+
* Licensed under the Apache License, Version 2.0 (the "License");
5+
* you may not use this file except in compliance with the License.
6+
* You may obtain a copy of the License at
7+
*
8+
* http://www.apache.org/licenses/LICENSE-2.0
9+
*
10+
* Unless required by applicable law or agreed to in writing, software
11+
* distributed under the License is distributed on an "AS IS" BASIS,
12+
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13+
* See the License for the specific language governing permissions and
14+
* limitations under the License.
15+
*/
16+
17+
#include "mock_syscalls.h"
18+
19+
int open(const char *pathname, int flags, ...)
20+
{
21+
auto &manager = onert::backend::trix::ops::test::MockSyscallsManager::getInstance();
22+
23+
// Handle variable arguments for open()
24+
if (flags & O_CREAT)
25+
{
26+
if (auto creatHook = manager.getOpenCreatHook())
27+
{
28+
va_list args;
29+
va_start(args, flags);
30+
mode_t mode = va_arg(args, mode_t);
31+
va_end(args);
32+
return creatHook(pathname, flags, mode);
33+
}
34+
}
35+
else
36+
{
37+
if (auto hook = manager.getOpenHook())
38+
{
39+
return hook(pathname, flags);
40+
}
41+
}
42+
return 0; // Default mock return value
43+
}
44+
45+
void *mmap(void *addr, size_t length, int prot, int flags, int fd, off_t offset)
46+
{
47+
auto &manager = onert::backend::trix::ops::test::MockSyscallsManager::getInstance();
48+
if (auto hook = manager.getMmapHook())
49+
{
50+
return hook(addr, length, prot, flags, fd, offset);
51+
}
52+
return (void *)0x1; // Default mock return value
53+
}
54+
55+
int munmap(void *addr, size_t length)
56+
{
57+
auto &manager = onert::backend::trix::ops::test::MockSyscallsManager::getInstance();
58+
if (auto hook = manager.getMunmapHook())
59+
{
60+
return hook(addr, length);
61+
}
62+
return 0; // Default mock return value
63+
}
64+
65+
int close(int fd)
66+
{
67+
auto &manager = onert::backend::trix::ops::test::MockSyscallsManager::getInstance();
68+
if (auto hook = manager.getCloseHook())
69+
{
70+
return hook(fd);
71+
}
72+
return 0; // Default mock return value
73+
}
74+
75+
int ioctl(int fd, unsigned long request, ...)
76+
{
77+
auto &manager = onert::backend::trix::ops::test::MockSyscallsManager::getInstance();
78+
if (auto hook = manager.getIoctlHook())
79+
{
80+
va_list args;
81+
va_start(args, request);
82+
void *arg = va_arg(args, void *);
83+
va_end(args);
84+
return hook(fd, request, arg);
85+
}
86+
return 0; // Default mock return value
87+
}
88+
89+
FILE *fopen(const char *path, const char *mode)
90+
{
91+
auto &manager = onert::backend::trix::ops::test::MockSyscallsManager::getInstance();
92+
if (auto hook = manager.getFopenHook())
93+
{
94+
return hook(path, mode);
95+
}
96+
return (FILE *)0x1; // Default mock return value
97+
}
98+
99+
int fclose(FILE *stream)
100+
{
101+
auto &manager = onert::backend::trix::ops::test::MockSyscallsManager::getInstance();
102+
if (auto hook = manager.getFcloseHook())
103+
{
104+
return hook(stream);
105+
}
106+
return 0;
107+
}
108+
109+
size_t fread(void *ptr, size_t size, size_t nmemb, FILE *stream)
110+
{
111+
auto &manager = onert::backend::trix::ops::test::MockSyscallsManager::getInstance();
112+
if (auto hook = manager.getFreadHook())
113+
{
114+
return hook(ptr, size, nmemb, stream);
115+
}
116+
return 1; // Default mock return value
117+
}
118+
119+
int fseek(FILE *stream, long offset, int whence)
120+
{
121+
auto &manager = onert::backend::trix::ops::test::MockSyscallsManager::getInstance();
122+
if (auto hook = manager.getFseekHook())
123+
{
124+
return hook(stream, offset, whence);
125+
}
126+
return 0; // Default mock return value
127+
}

0 commit comments

Comments
 (0)