joshiayush / xtest Goto Github PK

View Code? Open in Web Editor NEW

2.0 1.0 2.0 305 KB

C++ testing framework inspired by googletest.

License: BSD 3-Clause "New" or "Revised" License

C++ 96.62% CMake 2.65% Shell 0.73%

c cmake cpplint googletest linux xtest cpp17

xtest's People

Contributors

Stargazers

Watchers

Forkers

panquesito7 rishabh-dhami

xtest's Issues

`ParseFlagValue()` returns `true` for non-value arguments when value arguments are used

Description

Currently while debugging, a bug has been come out where different flags are messing up with the algorithm. For example, flag nameshuffle is messing up with the algorithm when flag --color=no is used; ParseFlagValue() returns true for flag name shuffle when --color=no is used this is because of the statement *flag_end == '\0' in ParseFlagValue(). This is a bug in ParseFlagValue() and needs to be fixed.

Solution

A solution is to write a custom algorithm that will find the flag value in the given flag while also taking into account if the value is defined optional or not.

xtest/xtest/xtest.cc

Lines 483 to 501 in 5a06d39

    
           static const std::string ParseFlagValue(const char* const flag, 
        
                                                   const char* flag_name, 
        
                                                   bool def_optional) { 
        
             if (flag == nullptr || flag_name == nullptr) 
        
               return std::string(); 
        
             uint8_t preffix_len = ValidFlagPreffixLength(flag); 
        
             if (preffix_len == 0) 
        
               return std::string(); 
        
             const char* flag_end = flag + (preffix_len + std::strlen(flag_name) + 1); 
        
             if (def_optional && *flag_end == '\0') 
        
               return "true"; 
        
             if (*flag_end != '=') 
        
               return std::string(); 
        
             return ++flag_end; 
        
           }

Replacing this fairly simple algorithm with a more robust one might help in solving this bug. I'll upload a more robust algorithm once I'll get time for it.

Capture output stream (stdout/stderr)

At the moment, we don't have any API that can also capture the output streams (stdout/stderr), so even to test our own xtest API we have to use the redirector API that we have inside of our tests which is not completely efficient. So, what I have decided to do is to implement a CapturedStream API similar to the one that googletest uses.

Problems with RedirectorContext:

We have to explicitly pass the type of the stream we want to capture.
We have to manually replace the stream file with our own context buffer.
We also have to restore the stream manually.

What googletest have for us:

Simplicity; (following example is taken from the cjson library).

testing::internal::CaptureStdout();
PrintSstream(&sstream, FALSE);
std::string stdout_output = testing::internal::GetCapturedStdout();

Flag `--color` has not effect on the library

Description

It has been noticed that providing flag --color with either no or yes value has no effect on the output of the library.

joshiayush / xtest Goto Github PK

xtest's People

Contributors

Stargazers

Watchers

Forkers

xtest's Issues

`ParseFlagValue()` returns `true` for non-value arguments when value arguments are used

Description

Solution

Capture output stream (stdout/stderr)

Flag `--color` has not effect on the library

Description

Recommend Projects

React

Vue.js

Typescript

TensorFlow

Django

Laravel

D3

Recommend Topics

javascript

web

server

Machine learning

Visualization

Game

Recommend Org

Facebook

Microsoft

Google

Alibaba

D3

Tencent

	static const std::string ParseFlagValue(const char* const flag,
	const char* flag_name,
	bool def_optional) {
	if (flag == nullptr \|\| flag_name == nullptr)
	return std::string();

	uint8_t preffix_len = ValidFlagPreffixLength(flag);
	if (preffix_len == 0)
	return std::string();

	const char* flag_end = flag + (preffix_len + std::strlen(flag_name) + 1);
	if (def_optional && *flag_end == '\0')
	return "true";

	if (*flag_end != '=')
	return std::string();

	return ++flag_end;
	}