RCCService Game Server
Headless game server host, job management, and RCC Arbiter synchronization.
Subsystem Metrics
- Total Documented Functions:
854 - Functions Exercised in Tests:
24 - Platform-Divergent Implementations:
20 - Component Source Files:
19
Source Files
View all 19 source files in this subsystem
| Source File | Path |
|---|---|
DummyWindow.cpp | RCCService/DummyWindow.cpp |
OperationalSecurity.cpp | RCCService/OperationalSecurity.cpp |
RCCService.cpp | RCCService/RCCService.cpp |
RCCServiceSoapServiceImpl.cpp | RCCService/RCCServiceSoapServiceImpl.cpp |
ThumbnailGenerator.cpp | RCCService/ThumbnailGenerator.cpp |
soapC.cpp | RCCService/gSOAP/generated/soapC.cpp |
soapRCCServiceSoap12Service.cpp | RCCService/gSOAP/generated/soapRCCServiceSoap12Service.cpp |
soapRCCServiceSoapService.cpp | RCCService/gSOAP/generated/soapRCCServiceSoapService.cpp |
soapStub.h | RCCService/gSOAP/generated/soapStub.h |
wsa.h | RCCService/gSOAP/import/wsa.h |
stdsoap2.cpp | RCCService/gSOAP/stdsoap2.cpp |
stdsoap2.h | RCCService/gSOAP/stdsoap2.h |
JobManager.cs | Roblox.RccServiceArbiter/JobManager.cs |
Log.cs | Roblox.RccServiceArbiter/Log.cs |
Program.cs | Roblox.RccServiceArbiter/Program.cs |
RccService.cs | Roblox.RccServiceArbiter/RccService.cs |
RccServiceMonitor.cs | Roblox.RccServiceArbiter/RccServiceMonitor.cs |
TcpPort.cs | Roblox.RccServiceArbiter/TcpPort.cs |
Util.cs | Roblox.RccServiceArbiter/Util.cs |
Function Reference
1. DefineMyClass
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
WNDCLASS DefineMyClass(WNDPROC winProc, LPCTSTR className, HINSTANCE hInst);
| Property | Value |
|---|---|
| Return Type | WNDCLASS |
| Modifiers | None |
| Source Location | RCCService/DummyWindow.cpp:2 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes DefineMyClass within RCCService Game Server. Coordinates interactions with Style, LoadCursor.
- Control Flow & Execution: Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
Style,LoadCursor.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on DefineMyClass.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
2. CreateMyWindow
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
HWND CreateMyWindow(LPCTSTR caption, LPCTSTR className, HINSTANCE hInstance, int width, int height);
| Property | Value |
|---|---|
| Return Type | HWND |
| Modifiers | None |
| Source Location | RCCService/DummyWindow.cpp:21 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes CreateMyWindow within RCCService Game Server. Coordinates interactions with CreateWindow, produce, frame, window.
- Control Flow & Execution: Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
CreateWindow,produce,frame,window.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on CreateMyWindow.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
3. WindowProcedure
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
LRESULT CALLBACK WindowProcedure(HWND hwnd, unsigned int message, WPARAM wParam, LPARAM lParam);
| Property | Value |
|---|---|
| Return Type | LRESULT CALLBACK |
| Modifiers | None |
| Source Location | RCCService/DummyWindow.cpp:37 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes WindowProcedure within RCCService Game Server. Coordinates interactions with PostQuitMessage, DefWindowProc.
- Control Flow & Execution: Multi-case state dispatch, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
PostQuitMessage,DefWindowProc.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on WindowProcedure.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
4. handle
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
: handle(0);
| Property | Value |
|---|---|
| Return Type | : |
| Modifiers | None |
| Source Location | RCCService/DummyWindow.cpp:49 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes handle within RCCService Game Server. Coordinates interactions with GetModuleHandle, DefineMyClass, RegisterClass, CreateMyWindow.
- Control Flow & Execution: Direct sequential execution.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
GetModuleHandle,DefineMyClass,RegisterClass,CreateMyWindow.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on handle.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
5. rccBigFunc
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void rccBigFunc();
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | __forceinline |
| Source Location | RCCService/OperationalSecurity.cpp:17 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes rccBigFunc within RCCService Game Server.
- Control Flow & Execution: Direct sequential execution.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on rccBigFunc.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
6. rccBigFuncStorage
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void rccBigFuncStorage();
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | RCCService/OperationalSecurity.cpp:41 |
| Subsystem | RCCService Game Server |
How it Works Internally
__declspec(align(4096)) didn't work, so this should be 8192 bytes large to ensure it fills one page fully.
- Control Flow & Execution: Direct sequential execution.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
defined.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on rccBigFuncStorage.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
7. getGuardPageBase
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
uintptr_t getGuardPageBase();
| Property | Value |
|---|---|
| Return Type | uintptr_t |
| Modifiers | None |
| Source Location | RCCService/OperationalSecurity.cpp:49 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes getGuardPageBase within RCCService Game Server.
- Control Flow & Execution: Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getGuardPageBase.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
8. getSectionInfo
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
bool getSectionInfo(const SectionPtrVector& sections, const char* name, uintptr_t& baseAddr, size_t& size);
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | None |
| Source Location | RCCService/OperationalSecurity.cpp:56 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes getSectionInfo within RCCService Game Server. Coordinates interactions with size, strncmp, GetModuleHandle.
- Control Flow & Execution: Iterative loop processing, Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
size,strncmp,GetModuleHandle.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getSectionInfo.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
9. getSections
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
int getSections(void* pImageBase, SectionPtrVector& sections);
| Property | Value |
|---|---|
| Return Type | int |
| Modifiers | None |
| Source Location | RCCService/OperationalSecurity.cpp:71 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes getSections within RCCService Game Server. Coordinates interactions with push_back.
- Control Flow & Execution: Iterative loop processing, Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
push_back.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getSections.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
10. rccReflectionModifiedVeh
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
LONG CALLBACK rccReflectionModifiedVeh(EXCEPTION_POINTERS* rec);
| Property | Value |
|---|---|
| Return Type | LONG CALLBACK |
| Modifiers | None |
| Source Location | RCCService/OperationalSecurity.cpp:104 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes rccReflectionModifiedVeh within RCCService Game Server. Coordinates interactions with GetModuleHandleA, addPoint, format, c_str.
- Control Flow & Execution: Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
GetModuleHandleA,addPoint,format,c_str,report,VirtualProtect. - External Library Dependencies:
InfluxDB Metrics Ingestion Client.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on rccReflectionModifiedVeh.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
11. rccBigFuncExceptionHandler
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
LONG CALLBACK rccBigFuncExceptionHandler(EXCEPTION_POINTERS* rec);
| Property | Value |
|---|---|
| Return Type | LONG CALLBACK |
| Modifiers | None |
| Source Location | RCCService/OperationalSecurity.cpp:133 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes rccBigFuncExceptionHandler within RCCService Game Server. Coordinates interactions with getGuardPageBase.
- Control Flow & Execution: Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
getGuardPageBase.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on rccBigFuncExceptionHandler.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
12. rccHwbpExceptionHandler
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
LONG CALLBACK rccHwbpExceptionHandler(EXCEPTION_POINTERS* rec);
| Property | Value |
|---|---|
| Return Type | LONG CALLBACK |
| Modifiers | None |
| Source Location | RCCService/OperationalSecurity.cpp:147 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes rccHwbpExceptionHandler within RCCService Game Server.
- Control Flow & Execution: Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on rccHwbpExceptionHandler.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
13. initAntiMemDump
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void initAntiMemDump();
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | RCCService/OperationalSecurity.cpp:156 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes initAntiMemDump within RCCService Game Server. Coordinates interactions with defined, AddVectoredExceptionHandler, VirtualProtect, GetModuleHandleA.
- Control Flow & Execution: Direct sequential execution.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
defined,AddVectoredExceptionHandler,VirtualProtect,GetModuleHandleA,memcpy,getGuardPageBase.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on initAntiMemDump.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
14. initHwbpVeh
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void initHwbpVeh();
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | RCCService/OperationalSecurity.cpp:174 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes initHwbpVeh within RCCService Game Server. Coordinates interactions with AddVectoredExceptionHandler.
- Control Flow & Execution: Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
AddVectoredExceptionHandler.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on initHwbpVeh.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
15. initLuaReadOnly
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void initLuaReadOnly();
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | RCCService/OperationalSecurity.cpp:183 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes initLuaReadOnly within RCCService Game Server. Coordinates interactions with getSections, GetModuleHandleA, getSectionInfo, AddVectoredExceptionHandler.
- Control Flow & Execution: Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
getSections,GetModuleHandleA,getSectionInfo,AddVectoredExceptionHandler,VirtualProtect.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on initLuaReadOnly.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
16. clearLuaReadOnly
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void clearLuaReadOnly();
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | RCCService/OperationalSecurity.cpp:204 |
| Subsystem | RCCService Game Server |
How it Works Internally
From testing, it looks like the crash reporter results in a crash and does not call all destructors, etc... However, in the normal case, this would prevent a crash at exit.
- Control Flow & Execution: Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
RemoveVectoredExceptionHandler,VirtualProtect.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on clearLuaReadOnly.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
17. process_request
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void process_request(RCCServiceSoapService *service);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | RCCService/RCCService.cpp:45 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes process_request within RCCService Game Server. Coordinates interactions with InterlockedIncrement, serve, RBXCRASH, InterlockedDecrement. Employs heap memory deallocation via operator delete.
- Control Flow & Execution: Direct sequential execution.
- Memory Management: Heap memory deallocation via operator delete.
- Concurrency & Thread Safety: Atomic atomic operations (lock-free thread safety).
- Error Handling & Invariants: Exception handling block (try/catch recovery).
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
InterlockedIncrement,serve,RBXCRASH,InterlockedDecrement.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on process_request.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
18. StringCrash
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void StringCrash(const char* s);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | static |
| Source Location | RCCService/RCCService.cpp:60 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes StringCrash within RCCService Game Server. Coordinates interactions with strncpy_s, RBXCRASH.
- Control Flow & Execution: Direct sequential execution.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
strncpy_s,RBXCRASH.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on StringCrash.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
19. dispatch
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
int dispatch();
| Property | Value |
|---|---|
| Return Type | int |
| Modifiers | virtual |
| Source Location | RCCService/RCCService.cpp:72 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes dispatch within RCCService Game Server. Coordinates interactions with printf, soap_receiver_fault, what, StringCrash.
- Control Flow & Execution: Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Exception handling block (try/catch recovery).
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
printf,soap_receiver_fault,what,StringCrash,c_str,RBXCRASH.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on dispatch.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
20. SvcReportEvent
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
VOID SvcReportEvent(WORD type, LPCTSTR szFunction);
| Property | Value |
|---|---|
| Return Type | VOID |
| Modifiers | None |
| Source Location | RCCService/RCCService.cpp:122 |
| Subsystem | RCCService Game Server |
How it Works Internally
http://msdn2.microsoft.com/en-us/library/ms687416(VS.85).aspx Purpose: Logs messages to the event log Parameters: szFunction - name of function that failed Return value: None Remarks: The service must have an entry in the Application event log.
- Control Flow & Execution: Conditional branching.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
RegisterEventSource,ReportEvent,identifier,DeregisterEventSource.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on SvcReportEvent.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
21. startupRCC
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void startupRCC(int port, LPCTSTR contentpath, bool crashUploaderOnly);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | static |
| Source Location | RCCService/RCCService.cpp:146 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes startupRCC within RCCService Game Server. Coordinates interactions with printf, start_CWebService, bind, soap_valid_socket.
- Control Flow & Execution: Conditional branching.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: C++ exception throw on invalid state or failure; Standard runtime error exception formulation.
- State Mutation: Mutates internal member state or instance properties.
- Key Internal Calls:
printf,start_CWebService,bind,soap_valid_socket,runtime_error,soap_faultstring,sprintf_s,singleton,print,SvcReportEvent. - External Library Dependencies:
OpenGL / GLES Graphics API.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on startupRCC.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
22. process_request_func
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
DWORD CALLBACK process_request_func(LPVOID param);
| Property | Value |
|---|---|
| Return Type | DWORD CALLBACK |
| Modifiers | None |
| Source Location | RCCService/RCCService.cpp:166 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes process_request_func within RCCService Game Server. Coordinates interactions with process_request.
- Control Flow & Execution: Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
process_request.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on process_request_func.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
23. stepRCC
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void stepRCC();
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | static |
| Source Location | RCCService/RCCService.cpp:172 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes stepRCC within RCCService Game Server. Coordinates interactions with runtime_error, format, accept, soap_valid_socket.
- Control Flow & Execution: Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: C++ exception throw on invalid state or failure; Standard runtime error exception formulation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
runtime_error,format,accept,soap_valid_socket,soap_faultstring,copy,QueueUserWorkItem,RBXCRASH.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on stepRCC.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
24. shutdownRCC
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void shutdownRCC();
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | static |
| Source Location | RCCService/RCCService.cpp:196 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes shutdownRCC within RCCService Game Server. Coordinates interactions with printf, stop_CWebService.
- Control Flow & Execution: Direct sequential execution.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
printf,stop_CWebService.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on shutdownRCC.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
25. UpdateState
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void UpdateState(DWORD state);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | RCCService/RCCService.cpp:212 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes UpdateState within RCCService Game Server. Coordinates interactions with SetServiceStatus.
- Control Flow & Execution: Direct sequential execution.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
SetServiceStatus.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on UpdateState.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
26. parsePort
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
int parsePort(int argc, _TCHAR* argv[]);
| Property | Value |
|---|---|
| Return Type | int |
| Modifiers | static |
| Source Location | RCCService/RCCService.cpp:219 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes parsePort within RCCService Game Server. Coordinates interactions with atoi.
- Control Flow & Execution: Iterative loop processing, Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
atoi.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on parsePort.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
27. parseBreakRequest
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
bool parseBreakRequest(int argc, _TCHAR* argv[]);
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | static |
| Source Location | RCCService/RCCService.cpp:231 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes parseBreakRequest within RCCService Game Server. Coordinates interactions with _tcsicmp.
- Control Flow & Execution: Iterative loop processing, Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
_tcsicmp.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on parseBreakRequest.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
28. parseContent
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
LPCTSTR parseContent(int argc, _TCHAR* argv[]);
| Property | Value |
|---|---|
| Return Type | LPCTSTR |
| Modifiers | static |
| Source Location | RCCService/RCCService.cpp:246 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes parseContent within RCCService Game Server. Coordinates interactions with _tcsncicmp.
- Control Flow & Execution: Iterative loop processing, Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
_tcsncicmp.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on parseContent.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
29. parse
Status: 🧪 Tested | 🌐 Cross-Platform Uniform
LPCTSTR parse(const _TCHAR szTag[], int tagLen, int argc, _TCHAR* argv[]);
| Property | Value |
|---|---|
| Return Type | LPCTSTR |
| Modifiers | static |
| Source Location | RCCService/RCCService.cpp:265 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes parse within RCCService Game Server. Coordinates interactions with _tcsncicmp.
- Control Flow & Execution: Iterative loop processing, Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
_tcsncicmp.
How it is Used in Tests
This function is exercised in 1 test case(s):
Xml::Parse(App.UnitTest/XmlElement.cpp:12)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_REQUIRE(node->getValue(value)),BOOST_CHECK_EQUAL(value, "\"hello world\"") - Callsite Snippet:
std::auto_ptr<XmlElement> node = machine.parse();
- Usage Pattern:
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
30. parsePlaceId
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
int parsePlaceId(int argc, _TCHAR* argv[]);
| Property | Value |
|---|---|
| Return Type | int |
| Modifiers | static |
| Source Location | RCCService/RCCService.cpp:282 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes parsePlaceId within RCCService Game Server. Coordinates interactions with parse, atoi.
- Control Flow & Execution: Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
parse,atoi.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on parsePlaceId.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
31. parseMD5
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
LPCTSTR parseMD5(int argc, _TCHAR* argv[]);
| Property | Value |
|---|---|
| Return Type | LPCTSTR |
| Modifiers | static |
| Source Location | RCCService/RCCService.cpp:293 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes parseMD5 within RCCService Game Server. Coordinates interactions with parse.
- Control Flow & Execution: Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
parse.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on parseMD5.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
32. parseSettingsKey
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
LPCTSTR parseSettingsKey(int argc, _TCHAR* argv[]);
| Property | Value |
|---|---|
| Return Type | LPCTSTR |
| Modifiers | static |
| Source Location | RCCService/RCCService.cpp:298 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes parseSettingsKey within RCCService Game Server. Coordinates interactions with parse.
- Control Flow & Execution: Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
parse.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on parseSettingsKey.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
33. Handler
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void WINAPI Handler(DWORD control);
| Property | Value |
|---|---|
| Return Type | void WINAPI |
| Modifiers | None |
| Source Location | RCCService/RCCService.cpp:305 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes Handler within RCCService Game Server. Coordinates interactions with ASSERT, UpdateState, singleton, print.
- Control Flow & Execution: Direct sequential execution.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Mutates internal member state or instance properties.
- Key Internal Calls:
ASSERT,UpdateState,singleton,print,SvcReportEvent,shutdownRCC,WaitForSingleObject. - External Library Dependencies:
OpenGL / GLES Graphics API.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on Handler.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
34. ServiceMain
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
VOID WINAPI ServiceMain(DWORD dwArgc, LPTSTR *lpszArgv);
| Property | Value |
|---|---|
| Return Type | VOID WINAPI |
| Modifiers | None |
| Source Location | RCCService/RCCService.cpp:324 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes ServiceMain within RCCService Game Server. Coordinates interactions with CreateEvent, TEXT, RegisterServiceCtrlHandler, ASSERT.
- Control Flow & Execution: Iterative loop processing, Conditional branching.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Exception handling block (try/catch recovery).
- State Mutation: Mutates internal member state or instance properties.
- Key Internal Calls:
CreateEvent,TEXT,RegisterServiceCtrlHandler,ASSERT,UpdateState,parsePort,parseContent,startupRCC,singleton,print,SvcReportEvent,what. - External Library Dependencies:
OpenGL / GLES Graphics API.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on ServiceMain.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
35. SC_HANDLE
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
operator SC_HANDLE() const;
| Property | Value |
|---|---|
| Return Type | operator |
| Modifiers | const |
| Source Location | RCCService/RCCService.cpp:385 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes SC_HANDLE within RCCService Game Server.
- Control Flow & Execution: Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Immutable / read-only operation (const member method; does not alter object state).
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on SC_HANDLE.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
36. SvcUninstall
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
bool SvcUninstall(const char* name);
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | None |
| Source Location | RCCService/RCCService.cpp:387 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes SvcUninstall within RCCService Game Server. Coordinates interactions with OpenSCManager, OpenService, printf, failed.
- Control Flow & Execution: Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
OpenSCManager,OpenService,printf,failed,GetLastError,DeleteService.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on SvcUninstall.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
37. SvcStart
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void SvcStart(const char* name);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | RCCService/RCCService.cpp:407 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes SvcStart within RCCService Game Server. Coordinates interactions with OpenSCManager, OpenService, printf, failed.
- Control Flow & Execution: Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
OpenSCManager,OpenService,printf,failed,GetLastError,StartService.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on SvcStart.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
38. SvcStop
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void SvcStop(const char* name);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | RCCService/RCCService.cpp:428 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes SvcStop within RCCService Game Server. Coordinates interactions with OpenSCManager, OpenService, printf, failed.
- Control Flow & Execution: Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
OpenSCManager,OpenService,printf,failed,GetLastError,ControlService.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on SvcStop.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
39. EventLongUninstall
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void EventLongUninstall();
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | RCCService/RCCService.cpp:451 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes EventLongUninstall within RCCService Game Server. Coordinates interactions with Open, DeleteSubKey.
- Control Flow & Execution: Conditional branching.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
Open,DeleteSubKey.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on EventLongUninstall.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
40. EventLogInstall
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void EventLogInstall();
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | RCCService/RCCService.cpp:458 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes EventLogInstall within RCCService Game Server. Coordinates interactions with Create, runtime_error, GetModuleFileName, SetStringValue.
- Control Flow & Execution: Conditional branching.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: C++ exception throw on invalid state or failure; Standard runtime error exception formulation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
Create,runtime_error,GetModuleFileName,SetStringValue,SetDWORDValue.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on EventLogInstall.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
41. SvcInstall
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void SvcInstall();
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | RCCService/RCCService.cpp:473 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes SvcInstall within RCCService Game Server. Coordinates interactions with GetModuleFileName, runtime_error, OpenSCManager, CreateService. Employs dynamic heap allocation via c++ operator new.
- Control Flow & Execution: Iterative loop processing, Conditional branching, Multi-case state dispatch, Explicit result return.
- Memory Management: Dynamic heap allocation via C++ operator new; Unique RAII pointer lifetime control (boost::scoped_ptr).
- Concurrency & Thread Safety: Spinlock synchronization via RBX::spin_mutex; RAII mutex lock acquisition (scoped_lock); Thread mutual exclusion locking (boost::mutex); TaskScheduler global job queue dispatching.
- Error Handling & Invariants: C++ exception throw on invalid state or failure; Exception handling block (try/catch recovery); Standard runtime error exception formulation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
GetModuleFileName,runtime_error,OpenSCManager,CreateService,GetLastError,printf,ChangeServiceConfig2,Console,SetConsoleCtrlHandler,CtrlHandler,ReadAccessKey,empty. - External Library Dependencies:
Boost C++ Libraries,OpenGL / GLES Graphics API.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on SvcInstall.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
42. CtrlHandler
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
BOOL CtrlHandler(DWORD fdwCtrlType);
| Property | Value |
|---|---|
| Return Type | BOOL |
| Modifiers | static |
| Source Location | RCCService/RCCService.cpp:546 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes CtrlHandler within RCCService Game Server.
- Control Flow & Execution: Multi-case state dispatch, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on CtrlHandler.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
43. ReadAccessKey
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void ReadAccessKey();
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | RCCService/RCCService.cpp:570 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes ReadAccessKey within RCCService Game Server. Coordinates interactions with empty, lock, SUCCEEDED, Open.
- Control Flow & Execution: Conditional branching.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: RAII mutex lock acquisition (scoped_lock); Thread mutual exclusion locking (boost::mutex).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
empty,lock,SUCCEEDED,Open,QueryStringValue,string,singleton,printf,c_str. - External Library Dependencies:
Boost C++ Libraries,OpenGL / GLES Graphics API.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on ReadAccessKey.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
44. onMessage
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
protected:
void onMessage(const RBX::StandardOutMessage& message);
| Property | Value |
|---|---|
| Return Type | `protected: |
| void` | |
| Modifiers | None |
| Source Location | RCCService/RCCService.cpp:606 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes onMessage within RCCService Game Server. Coordinates interactions with lock, SetConsoleTextAttribute, printf, c_str.
- Control Flow & Execution: Multi-case state dispatch.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Spinlock synchronization via RBX::spin_mutex; RAII mutex lock acquisition (scoped_lock).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
lock,SetConsoleTextAttribute,printf,c_str.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on onMessage.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
45. _tmain
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
int _tmain(int argc, _TCHAR* argv[]);
| Property | Value |
|---|---|
| Return Type | int |
| Modifiers | None |
| Source Location | RCCService/RCCService.cpp:629 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes _tmain within RCCService Game Server. Coordinates interactions with _CrtSetDbgFlag, standardOutLog, PrintfLogger, ReadAccessKey. Employs dynamic heap allocation via c++ operator new.
- Control Flow & Execution: Iterative loop processing, Conditional branching.
- Memory Management: Dynamic heap allocation via C++ operator new; Unique RAII pointer lifetime control (boost::scoped_ptr).
- Concurrency & Thread Safety: TaskScheduler global job queue dispatching.
- Error Handling & Invariants: C++ exception throw on invalid state or failure; Exception handling block (try/catch recovery); Standard runtime error exception formulation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
_CrtSetDbgFlag,standardOutLog,PrintfLogger,ReadAccessKey,setWindowsNoFragHeap,_tcsicmp,EventLogInstall,SvcInstall,SvcUninstall,EventLongUninstall,SvcStart,SvcStop. - External Library Dependencies:
Boost C++ Libraries,OpenGL / GLES Graphics API.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on _tmain.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
46. run
Status: 🧪 Tested | ⚠️ Platform Divergent
void run(shared_ptr<boost::condition_variable_any> event, int timeount, shared_ptr<boost::mutex> mutex);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | static |
| Source Location | RCCService/RCCServiceSoapServiceImpl.cpp:149 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes run within RCCService Game Server. Coordinates interactions with xtime_get, lock, timed_wait, RBXCRASH.
- Control Flow & Execution: Conditional branching.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: RAII mutex lock acquisition (scoped_lock); Thread mutual exclusion locking (boost::mutex).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
xtime_get,lock,timed_wait,RBXCRASH. - External Library Dependencies:
Boost C++ Libraries.
How it is Used in Tests
This function is exercised in 30 test case(s):
Instance::WaitForChildReturnsImmediatelyIfChildPresent(App.UnitTest/Instance.cpp:264)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_CHECK_EQUAL(part->getName(), "Renamed") - Callsite Snippet:
ServiceProvider::create<RunService>(&dm)->run();
- Usage Pattern:
Instance::WaitForSameChildAfterInitialWaitForChild(App.UnitTest/Instance.cpp:289)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_CHECK_EQUAL(part->getName(), "Renamed") - Callsite Snippet:
ServiceProvider::create<RunService>(&dm)->run();
- Usage Pattern:
Instance::TwoScriptsWaitingForSameChild(App.UnitTest/Instance.cpp:314)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_CHECK(dm->getWorkspace()->findFirstChildByName("Alice") != NULL),BOOST_CHECK(dm->getWorkspace()->findFirstChildByName("Bob") != NULL) - Callsite Snippet:
ServiceProvider::create<RunService>(&dm)->run();
- Usage Pattern:
Instance::TwoScriptsWaitingForSameChildRenameOnResume(App.UnitTest/Instance.cpp:356)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_CHECK_EQUAL("PartBx", part->getName()),BOOST_CHECK_EQUAL("PartA", part2->getName()) - Callsite Snippet:
ServiceProvider::create<RunService>(&dm)->run();
- Usage Pattern:
Behavioral Differences Across Code Files
Divergence Analysis: Alternative platform-specific implementations exist in: Win/ScriptErrorUploader.cpp, Win/DumpErrorUploader.cpp.
- Alternative Implementation Files:
Win/ScriptErrorUploader.cpp,Win/DumpErrorUploader.cpp
47. fetchData
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
bool fetchData();
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | None |
| Source Location | RCCService/RCCServiceSoapServiceImpl.cpp:200 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes fetchData within RCCService Game Server. Coordinates interactions with request, get, singleton, printf.
- Control Flow & Execution: Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Exception handling block (try/catch recovery).
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
request,get,singleton,printf,c_str,what. - External Library Dependencies:
OpenGL / GLES Graphics API.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on fetchData.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
48. ~SecurityDataUpdater
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
virtual ~SecurityDataUpdater();
| Property | Value |
|---|---|
| Return Type | virtual |
| Modifiers | None |
| Source Location | RCCService/RCCServiceSoapServiceImpl.cpp:225 |
| Subsystem | RCCService Game Server |
How it Works Internally
Declaration or inline method for ~SecurityDataUpdater.
- Control Flow & Execution: Linear execution flow.
- Memory Management: Standard stack allocation.
- Concurrency & Thread Safety: Unsynchronized / single-threaded context.
- Error Handling & Invariants: Standard return value verification.
- State Mutation: Stateless or local modification.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on ~SecurityDataUpdater.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
49. run
Status: 🧪 Tested | ⚠️ Platform Divergent
void run();
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | RCCService/RCCServiceSoapServiceImpl.cpp:226 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes run within RCCService Game Server. Coordinates interactions with fetchData, jsonResult, parseJSONTable, find. Employs reference-counted heap object ownership (boost::shared_ptr).
- Control Flow & Execution: Conditional branching, Explicit result return.
- Memory Management: Reference-counted heap object ownership (boost::shared_ptr).
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
fetchData,jsonResult,parseJSONTable,find,end,processDataArray.
How it is Used in Tests
This function is exercised in 30 test case(s):
Instance::WaitForChildReturnsImmediatelyIfChildPresent(App.UnitTest/Instance.cpp:264)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_CHECK_EQUAL(part->getName(), "Renamed") - Callsite Snippet:
ServiceProvider::create<RunService>(&dm)->run();
- Usage Pattern:
Instance::WaitForSameChildAfterInitialWaitForChild(App.UnitTest/Instance.cpp:289)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_CHECK_EQUAL(part->getName(), "Renamed") - Callsite Snippet:
ServiceProvider::create<RunService>(&dm)->run();
- Usage Pattern:
Instance::TwoScriptsWaitingForSameChild(App.UnitTest/Instance.cpp:314)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_CHECK(dm->getWorkspace()->findFirstChildByName("Alice") != NULL),BOOST_CHECK(dm->getWorkspace()->findFirstChildByName("Bob") != NULL) - Callsite Snippet:
ServiceProvider::create<RunService>(&dm)->run();
- Usage Pattern:
Instance::TwoScriptsWaitingForSameChildRenameOnResume(App.UnitTest/Instance.cpp:356)- Usage Pattern:
Direct Call - Assertions Checked:
BOOST_CHECK_EQUAL("PartBx", part->getName()),BOOST_CHECK_EQUAL("PartA", part2->getName()) - Callsite Snippet:
ServiceProvider::create<RunService>(&dm)->run();
- Usage Pattern:
Behavioral Differences Across Code Files
Divergence Analysis: Alternative platform-specific implementations exist in: Win/ScriptErrorUploader.cpp, Win/DumpErrorUploader.cpp.
- Alternative Implementation Files:
Win/ScriptErrorUploader.cpp,Win/DumpErrorUploader.cpp
50. processDataArray
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
protected:
void processDataArray(shared_ptr<const RBX::Reflection::ValueArray> dataArray);
| Property | Value |
|---|---|
| Return Type | `protected: |
| void` | |
| Modifiers | None |
| Source Location | RCCService/RCCServiceSoapServiceImpl.cpp:247 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes processDataArray within RCCService Game Server. Coordinates interactions with begin, end, insert, setGoldenHashes2.
- Control Flow & Execution: Iterative loop processing.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
begin,end,insert,setGoldenHashes2.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on processDataArray.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
51. processDataArray
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
protected:
void processDataArray(shared_ptr<const RBX::Reflection::ValueArray> dataArray);
| Property | Value |
|---|---|
| Return Type | `protected: |
| void` | |
| Modifiers | None |
| Source Location | RCCService/RCCServiceSoapServiceImpl.cpp:270 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes processDataArray within RCCService Game Server. Coordinates interactions with begin, end, sha1, push_back.
- Control Flow & Execution: Iterative loop processing.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
begin,end,sha1,push_back,setSecurityVersions.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on processDataArray.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
52. populateMemHashConfigs
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void populateMemHashConfigs(RBX::Network::MemHashConfigs& hashConfigs, const std::string& cfgStr);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | static |
| Source Location | RCCService/RCCServiceSoapServiceImpl.cpp:294 |
| Subsystem | RCCService Game Server |
How it Works Internally
this is public until we get a web api to do this better.
- Control Flow & Execution: Iterative loop processing, Conditional branching.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
push_back,MemHashVector,back,split,is_any_of,begin,end,size. - External Library Dependencies:
Boost C++ Libraries.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on populateMemHashConfigs.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
53. processDataArray
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
protected:
void processDataArray(shared_ptr<const RBX::Reflection::ValueArray> dataArray);
| Property | Value |
|---|---|
| Return Type | `protected: |
| void` | |
| Modifiers | None |
| Source Location | RCCService/RCCServiceSoapServiceImpl.cpp:315 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes processDataArray within RCCService Game Server. Coordinates interactions with begin, end, populateMemHashConfigs, setGoldMemHashes.
- Control Flow & Execution: Iterative loop processing.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
begin,end,populateMemHashConfigs,setGoldMemHashes.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on processDataArray.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
54. ProcessVariable
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void ProcessVariable(const std::string& valueName, const std::string& valueData, bool dynamic);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | virtual |
| Source Location | RCCService/RCCServiceSoapServiceImpl.cpp:339 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes ProcessVariable within RCCService Game Server. Coordinates interactions with RBXASSERT, insert, make_pair.
- Control Flow & Execution: Direct sequential execution.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Engine invariant assertion check (RBXASSERT).
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
RBXASSERT,insert,make_pair.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on ProcessVariable.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
55. DefaultHandler
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
bool DefaultHandler(const std::string& valueName, const std::string& valueData);
| Property | Value |
|---|---|
| Return Type | bool |
| Modifiers | virtual |
| Source Location | RCCService/RCCServiceSoapServiceImpl.cpp:344 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes DefaultHandler within RCCService Game Server.
- Control Flow & Execution: Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on DefaultHandler.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
56. UpdateSettings
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void UpdateSettings();
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | RCCService/RCCServiceSoapServiceImpl.cpp:353 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes UpdateSettings within RCCService Game Server. Coordinates interactions with begin, end, SetValue, clear.
- Control Flow & Execution: Iterative loop processing.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
begin,end,SetValue,clear.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on UpdateSettings.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
57. getJob
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
JobMap::iterator getJob(const std::string& jobID);
| Property | Value |
|---|---|
| Return Type | JobMap::iterator |
| Modifiers | None |
| Source Location | RCCService/RCCServiceSoapServiceImpl.cpp:444 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes getJob within RCCService Game Server. Coordinates interactions with find, end, runtime_error, c_str.
- Control Flow & Execution: Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: C++ exception throw on invalid state or failure; Standard runtime error exception formulation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
find,end,runtime_error,c_str.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on getJob.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
58. validateSecurityData
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void validateSecurityData();
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | RCCService/RCCServiceSoapServiceImpl.cpp:451 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes validateSecurityData within RCCService Game Server. Coordinates interactions with WaitForSingleObject, GetValueSecurityDataTimer, run, fetchAllowedSecurityVersions. Employs dynamic heap allocation via c++ operator new.
- Control Flow & Execution: Iterative loop processing, Conditional branching.
- Memory Management: Dynamic heap allocation via C++ operator new.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
WaitForSingleObject,GetValueSecurityDataTimer,run,fetchAllowedSecurityVersions,setSecurityVersions,size,populateMemHashConfigs,setGoldMemHashes. - External Library Dependencies:
OpenGL / GLES Graphics API.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on validateSecurityData.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
59. validateClientSettings
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void validateClientSettings();
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | RCCService/RCCServiceSoapServiceImpl.cpp:493 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes validateClientSettings within RCCService Game Server. Coordinates interactions with WaitForSingleObject, GetValueClientSettingsTimer, LoadClientSettings, ReadFromStream. Employs reference-counted heap object ownership (boost::shared_ptr).
- Control Flow & Execution: Iterative loop processing, Conditional branching.
- Memory Management: Reference-counted heap object ownership (boost::shared_ptr).
- Concurrency & Thread Safety: RAII mutex lock acquisition (scoped_lock); Thread mutual exclusion locking (boost::mutex).
- Error Handling & Invariants: Relies on standard return codes and caller validation.
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
WaitForSingleObject,GetValueClientSettingsTimer,LoadClientSettings,ReadFromStream,c_str,lock,size,begin,submitTask,bind,UpdateSettings. - External Library Dependencies:
Boost C++ Libraries,OpenGL / GLES Graphics API.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on validateClientSettings.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
60. doCheckLease
Status: ⚪ Untested in Suites | 🌐 Cross-Platform Uniform
void doCheckLease(boost::shared_ptr<JobItem> job);
| Property | Value |
|---|---|
| Return Type | void |
| Modifiers | None |
| Source Location | RCCService/RCCServiceSoapServiceImpl.cpp:528 |
| Subsystem | RCCService Game Server |
How it Works Internally
Executes doCheckLease within RCCService Game Server. Coordinates interactions with secondsToTimeout, closeJob, WaitForSingleObject, assert.
- Control Flow & Execution: Iterative loop processing, Conditional branching, Explicit result return.
- Memory Management: Stack-based automatic variable allocation.
- Concurrency & Thread Safety: Unsynchronized execution (caller must ensure thread-safety if shared).
- Error Handling & Invariants: Exception handling block (try/catch recovery).
- State Mutation: Pure computational logic or modifies passed-in parameters/references.
- Key Internal Calls:
secondsToTimeout,closeJob,WaitForSingleObject,assert,singleton,printf,what. - External Library Dependencies:
OpenGL / GLES Graphics API.
How it is Used in Tests
No dedicated unit test case directly exercises this function by name.
This function is invoked indirectly through higher-level simulation or integration workloads. To add direct test coverage, introduce a test case in App.UnitTest or Base.UnitTest asserting state changes on doCheckLease.
Behavioral Differences Across Code Files
This function maintains identical behavior across all target platforms (_WIN32, macOS, iOS, Android, and Xbox Durango). It compiles into the same binary instructions without conditional preprocessor branching.
There are 794 additional internal and inline functions in this subsystem. All functions are indexed and cross-referenced in the Complete Function Catalog.