void
MediaDecoderReaderWrapper::RequestAudioData()
{
MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
MOZ_ASSERT(!mShutdown);
MOZ_ASSERT(mRequestAudioDataCB, "Request audio data without callback!");
auto p = InvokeAsync(mReader->OwnerThread(), mReader.get(), __func__,
&MediaDecoderReader::RequestAudioData);
if (!mStartTimeRendezvous->HaveStartTime()) {
p = p->Then(mOwnerThread, __func__, mStartTimeRendezvous.get(),
&StartTimeRendezvous::ProcessFirstSample<MediaData::AUDIO_DATA>,
&StartTimeRendezvous::FirstSampleRejected<MediaData::AUDIO_DATA>)
->CompletionPromise();
}
RefPtr<MediaDecoderReaderWrapper> self = this;
mAudioDataRequest.Begin(p->Then(mOwnerThread, __func__,
[self] (MediaData* aAudioSample) {
MOZ_ASSERT(self->mRequestAudioDataCB);
self->mAudioDataRequest.Complete();
self->OnSampleDecoded(self->mRequestAudioDataCB.get(), aAudioSample, TimeStamp());
},
[self] (MediaDecoderReader::NotDecodedReason aReason) {
MOZ_ASSERT(self->mRequestAudioDataCB);
self->mAudioDataRequest.Complete();
self->OnNotDecoded(self->mRequestAudioDataCB.get(), aReason);
}));
}
static Ret translate_one(interpreter_interface* interface, Inputs... rest, LiteralList& args, int offset) {
uint32_t ptr_t = args.at((uint32_t)offset - 2).geti32();
uint32_t ptr_u = args.at((uint32_t)offset - 1).geti32();
size_t length = args.at((uint32_t)offset).geti32();
static_assert(std::is_same<std::remove_const_t<T>, char>::value && std::is_same<std::remove_const_t<U>, char>::value, "Currently only support array of (const)chars");
return Then(interface, array_ptr_impl<T>(interface, ptr_t, length), array_ptr_impl<U>(interface, ptr_u, length), length, args, (uint32_t)offset - 3);
};
constexpr auto Static_If(TrueFunctor trueFunctor)
{
auto sIf = internal::static_if_internal<Condition>{};
sIf.Then(trueFunctor);
return sIf;
}
void posix_words() {
Primitive( "getwd", &_getwd );
Colon( "pwd" ); c("getwd"); c("type"); c("cr"); End();
Primitive( "(getenv)", &_getenv );
Primitive( "(setenv)", &_setenv );
Colon( "getenv" ); c("parse-word"); c("(getenv)"); End();
Colon( "setenv" ); c("parse-word"); c("parse-word"); c("(setenv)"); End();
Colon( "printenv" );
c("parse-word"); c("2dup"); c("type");
Literal((Cell)'='); c("emit");
c("(getenv)"); If(); c("type"); Then(); c("cr"); End();
Primitive( "(system)", &_system );
Primitive( "(exec)", &_exec );
/* mmap() protection */
Constant( "PROT_EXEC", (Cell)PROT_EXEC );
Constant( "PROT_READ", (Cell)PROT_READ );
Constant( "PROT_WRITE", (Cell)PROT_WRITE );
Constant( "PROT_NONE", (Cell)PROT_NONE );
/* mmap() Flags */
Constant( "MAP_FIXED", (Cell)MAP_FIXED );
Constant( "MAP_SHARED", (Cell)MAP_SHARED );
Constant( "MAP_PRIVATE", (Cell)MAP_PRIVATE );
Primitive( "mmap", &do_mmap );
Primitive( "getpid", &_getpid );
Primitive( "getppid", &_getppid );
/* Signals for kill */
Constant( "SIGHUP", (Cell)SIGHUP );
Constant( "SIGINT", (Cell)SIGINT );
Constant( "SIGQUIT", (Cell)SIGQUIT );
Constant( "SIGILL", (Cell)SIGILL );
Constant( "SIGTRAP", (Cell)SIGTRAP );
Constant( "SIGABRT", (Cell)SIGABRT );
Constant( "SIGIOT", (Cell)SIGIOT );
Constant( "SIGBUS", (Cell)SIGBUS );
Constant( "SIGFPE", (Cell)SIGFPE );
Constant( "SIGKILL", (Cell)SIGKILL );
Constant( "SIGUSR1", (Cell)SIGUSR1 );
Constant( "SIGSEGV", (Cell)SIGSEGV );
Constant( "SIGUSR2", (Cell)SIGUSR2 );
Constant( "SIGPIPE", (Cell)SIGPIPE );
Constant( "SIGALRM", (Cell)SIGALRM );
Constant( "SIGTERM", (Cell)SIGTERM );
// Constant( "SIGSTKFLT", (Cell)SIGSTKFLT );
// Constant( "SIGCLD", (Cell)SIGCLD );
Constant( "SIGCHLD", (Cell)SIGCHLD );
Constant( "SIGCONT", (Cell)SIGCONT );
Constant( "SIGSTOP", (Cell)SIGSTOP );
Constant( "SIGTSTP", (Cell)SIGTSTP );
Primitive( "kill", &_kill );
}
virtual void Run()
{
Then("a vector and list with same content in the same order are equivalent", []() {
AssertThat(ut11::Is::Iterable::Not::EquivalentTo(std::vector<int>({1,2,3,4,5,6,7,8}))(std::list<int>({1,2,3,4,5,6,7,8})), ut11::Is::False);
});
Then("a vector and list with same content in a different order are equivalent", []() {
AssertThat(ut11::Is::Iterable::Not::EquivalentTo(std::vector<int>({1,2,3,4,5,6,7,8}))(std::list<int>({7,8,5,1,4,3,2,6})), ut11::Is::False);
});
Then("a vector and list with different content are not equivalent", []() {
AssertThat(ut11::Is::Iterable::Not::EquivalentTo(std::vector<int>({1,2,3,4,5,6,7,8}))(std::list<int>({17,28,35,41})), ut11::Is::True);
});
Then("a vector and list with different but overlapping content are not equivalent", []() {
AssertThat(ut11::Is::Iterable::Not::EquivalentTo(std::vector<int>({1,2,3,4,5,6,7,8}))(std::list<int>({7,8,5,1})), ut11::Is::True);
});
Then("a vector and list with different content with same size are not equivalent", []() {
AssertThat(ut11::Is::Iterable::Not::EquivalentTo(std::vector<int>({1,2,3,4,5,6,7,8}))(std::list<int>({0,1,2,3,4,5,6,7})), ut11::Is::True);
});
Then("Is::Iterable::EquivalentTo() is an operand", []() {
AssertThat(ut11::detail::IsOperand< decltype(ut11::Is::Iterable::EquivalentTo(std::vector<int>())) >::value, ut11::Is::True);
});
Then("Is::EqualTo has an error message", []() {
AssertThat(ut11::Is::Iterable::EquivalentTo(std::vector<int>()).GetErrorMessage(0), ut11::Is::Not::EqualTo(""));
});
}
virtual void Run()
{
Then("string containing desired string is true", [&]() {
AssertThat(ut11::Is::String::Containing("Hell")("AvsdaHelloasdagf"), ut11::Is::True);
});
Then("string not containing desired string is false", [&]() {
AssertThat(ut11::Is::String::Containing("World")("AvsdaHelloasdagf"), ut11::Is::False);
});
Then("Is::String::Containing is an operand", []() {
AssertThat(ut11::detail::IsOperand< decltype(ut11::Is::String::Containing("world")) >::value, ut11::Is::True);
});
Then("Is::String::Containing has an error message", []() {
AssertThat(ut11::Is::String::Containing("world").GetErrorMessage("piano"), ut11::Is::Not::EqualTo(""));
});
}
bool ut11::detail::TestStageImpl::Run(out::Output& output)
{
if (!m_once.description.empty())
{
output.OnInfo(m_once.description);
return true;
}
auto runInsideTryCatch = [&](std::function<void(void)> func) -> bool {
try
{
func();
}
catch (const ut11::detail::TestFailedException& ex)
{
output.OnError(ex.GetLine(), ex.GetFile(), ex.GetMessage());
return false;
}
catch(const std::exception& ex)
{
output.OnError(ex);
return false;
}
catch(...)
{
output.OnUnknownError();
return false;
}
return true;
};
auto theFinallyFunction = [&]() -> void {
output.EndTest();
Finally(output);
};
auto theGivenWhenThenFinallyFunctions = [&]() -> void
{
output.BeginTest();
Given(output);
When(output);
Then(output);
theFinallyFunction();
};
if (!runInsideTryCatch(theGivenWhenThenFinallyFunctions))
{
runInsideTryCatch(theFinallyFunction);
return false;
}
return true;
}
virtual void Run()
{
Then("Is::Infinity(0.0f) is False", []() {
AssertThat(ut11::Is::Infinity(0.0f), ut11::Is::False);
});
Then("Is::Infinity(Infinity) is True", []() {
AssertThat(ut11::Is::Infinity(std::numeric_limits<float>::infinity()), ut11::Is::True);
AssertThat(ut11::Is::Infinity(-std::numeric_limits<float>::infinity()), ut11::Is::True);
});
Then("Is::Infinity is Operand", []() {
AssertThat(ut11::detail::IsOperand< decltype(ut11::Is::Infinity) >::value, ut11::Is::True);
});
Then("Is::Infinity has an error message", []() {
AssertThat(ut11::Is::Infinity.GetErrorMessage(0.0f), ut11::Is::Not::EqualTo(""));
});
}
void
MediaDecoderReaderWrapper::RequestVideoData(bool aSkipToNextKeyframe,
media::TimeUnit aTimeThreshold)
{
MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
MOZ_ASSERT(!mShutdown);
MOZ_ASSERT(mRequestVideoDataCB, "Request video data without callback!");
// Time the video decode and send this value back to callbacks who accept
// a TimeStamp as its second parameter.
TimeStamp videoDecodeStartTime = TimeStamp::Now();
if (aTimeThreshold.ToMicroseconds() > 0 &&
mStartTimeRendezvous->HaveStartTime()) {
aTimeThreshold += StartTime();
}
auto p = InvokeAsync(mReader->OwnerThread(), mReader.get(), __func__,
&MediaDecoderReader::RequestVideoData,
aSkipToNextKeyframe, aTimeThreshold.ToMicroseconds());
if (!mStartTimeRendezvous->HaveStartTime()) {
p = p->Then(mOwnerThread, __func__, mStartTimeRendezvous.get(),
&StartTimeRendezvous::ProcessFirstSample<MediaData::VIDEO_DATA>,
&StartTimeRendezvous::FirstSampleRejected<MediaData::VIDEO_DATA>)
->CompletionPromise();
}
RefPtr<MediaDecoderReaderWrapper> self = this;
mVideoDataRequest.Begin(p->Then(mOwnerThread, __func__,
[self, videoDecodeStartTime] (MediaData* aVideoSample) {
MOZ_ASSERT(self->mRequestVideoDataCB);
self->mVideoDataRequest.Complete();
self->OnSampleDecoded(self->mRequestVideoDataCB.get(), aVideoSample, videoDecodeStartTime);
},
[self] (MediaDecoderReader::NotDecodedReason aReason) {
MOZ_ASSERT(self->mRequestVideoDataCB);
self->mVideoDataRequest.Complete();
self->OnNotDecoded(self->mRequestVideoDataCB.get(), aReason);
}));
}
virtual void Run()
{
Then("an empty string is empty", []() {
AssertThat(ut11::Is::Not::Empty(""), ut11::Is::False);
AssertThat(ut11::Is::Not::Empty(std::string("")), ut11::Is::False);
});
Then("an empty vector is empty", []() {
AssertThat(ut11::Is::Not::Empty(std::vector<int>()), ut11::Is::False);
});
Then("a string with content is not empty", []() {
AssertThat(ut11::Is::Not::Empty("String With Content"), ut11::Is::True);
AssertThat(ut11::Is::Not::Empty(std::string("String With Content")), ut11::Is::True);
});
Then("a vector with content is not empty", []() {
AssertThat(ut11::Is::Not::Empty(std::vector<int>({1,2,3})), ut11::Is::True);
});
Then("Is::Empty is an operand", []() {
AssertThat(ut11::detail::IsOperand< decltype(ut11::Is::Not::Empty) >::value, ut11::Is::True);
});
Then("Is::Empty has an error message", []() {
AssertThat(ut11::Is::Not::Empty.GetErrorMessage(""), ut11::Is::Not::EqualTo(""));
});
}
virtual void Run()
{
Then("a vector of type int is iterable of int so false", [&]() {
AssertThat(ut11::Is::Iterable::Not::Of<int>()(std::vector<int>()), ut11::Is::False);
});
Then("an int is not iterable of int so true", [&]() {
AssertThat(ut11::Is::Iterable::Not::Of<int>()(1), ut11::Is::True);
});
Then("a vector of type string not is iterable of int so true", [&]() {
AssertThat(ut11::Is::Iterable::Not::Of<int>()(std::vector<std::string>()), ut11::Is::True);
});
Then("a vector of a child is iterable of base class so false", [&]() {
AssertThat(ut11::Is::Iterable::Not::Of<BaseClass>()(std::vector<ChildClass>()), ut11::Is::False);
});
Then("Is::Iterable::Of<T>() is an operand", []() {
AssertThat(ut11::detail::IsOperand< decltype(ut11::Is::Iterable::Not::Of<int>()) >::value, ut11::Is::True);
});
Then("Is::EqualTo has an error message", []() {
AssertThat(ut11::Is::Iterable::Not::Of<int>().GetErrorMessage(std::vector<int>()), ut11::Is::Not::EqualTo(""));
});
}
void
MediaDecoderReaderWrapper::WaitForData(MediaData::Type aType)
{
MOZ_ASSERT(mOwnerThread->IsCurrentThreadIn());
MOZ_ASSERT(WaitCallbackRef(aType));
auto p = InvokeAsync(mReader->OwnerThread(), mReader.get(), __func__,
&MediaDecoderReader::WaitForData, aType);
RefPtr<MediaDecoderReaderWrapper> self = this;
WaitRequestRef(aType).Begin(p->Then(mOwnerThread, __func__,
[self] (MediaData::Type aType) {
MOZ_ASSERT(self->WaitCallbackRef(aType));
self->WaitRequestRef(aType).Complete();
self->WaitCallbackRef(aType)->OnResolved(aType);
},
[self, aType] (WaitForDataRejectValue aRejection) {
MOZ_ASSERT(self->WaitCallbackRef(aType));
self->WaitRequestRef(aType).Complete();
self->WaitCallbackRef(aType)->OnRejected(aRejection);
}));
}
/** \brief Load all the initial dictionary words.
*/
void
init_dictionary(int dictsize) {
init_compiler(dictsize);
memory_words();
compile_primitives();
compile_core_constants();
core_words();
core_extension_words();
compile_dictionary_words();
controlflow_words();
more_core_words();
compile_double();
string_words();
exception_words();
file_words();
format_words();
compile_stack_words();
implementation_words();
vocabulary_words();
interpreter_words();
platform_words();
/* FIX - NEED TO DO THESE */
// Primitive( "d<", &lesser ); /* ( d1 d2 -- f ) */
// Primitive( "d>", &lesser ); /* ( d1 d2 -- f ) */
// Primitive( "u*", &um_star ); /* ( x y -- x*y ) */
// Primitive( "du*", &um_star ); /* ( x y -- x*y ) */
// Primitive( "du/mod", &um_star ); /* ( x y -- x*y ) */
// Primitive( "du<", &um_star ); /* ( x y -- x*y ) */
// Primitive( "m+", &um_star ); /* ( x y -- x*y ) */
// Primitive( "m-", &um_star ); /* ( x y -- x*y ) */
// Primitive( "m*", &um_star ); /* ( x y -- x*y ) */
// Primitive( "m*/", &um_star ); /* ( x y -- x*y ) */
// Primitive( "m/", &um_star ); /* ( x y -- x*y ) */
// Primitive( "m/mod", &um_star ); /* ( x y -- x*y ) */
/* FIX - NEED TO DO THESE */
/* FIX - these two words are no longer used - why are they here ?? */
// Primitive( "um*", &um_star ); /* ( x y -- x*y ) */
// Colon( "udm*" ); /* ( d.lo d.hi n -- d.lo' d.hi' ) */
// c("tuck"); c("um*"); c("drop"); c("-rot"); c("um*");
// c("rot"); c("+"); End();
Colon( ".version" );
DotQuote("Portable ANS Forth - [email protected]");
c("cr");
End();
Colon( "rstrace" );
DotQuote("( R: ");
c("rp@");
c("rp0");
c("@");
Do();
c("i");
c(".");
c("space");
c("/cell");
PlusLoop();
DotQuote(" )");
c("cr");
End();
Variable( "argument-hook" );
/* To( Tick("ndrop"), "argument-hook" ); */
ACF x = find("unnest");
To( (Cell)x, "argument-hook" );
Colon( "cold" );
c(".version");
c("cold-chain");
/* included may be replaced with path-included which reads
FORTH_PATH environment variable to look in selected
directories */
c("debug");
c("@");
If();
DotQuote("Loading Forth files...");
Then();
/* StringLiteral("base.fth"); c("included"); */
DotQuote("loading base.fth");
c("cr");
StringLiteral("base.fth");
Tick("included");
c("catch");
c("?aborted");
If();
DotQuote("Failed to load.");
c("cr");
Then();
c("debug");
c("@");
If();
DotQuote("done.");
c("cr");
Then();
c("hex");
#if 0
c("argument-hook");
c("@");
Tick("execute");
c("catch");
c("?aborted");
If();
DotQuote("argument-hook failed");
c("cr");
Then();
#endif
c("read-eval-loop");
End();
Colon( "warm" );
DotQuote( "Warm Started." );
c("cr");
c("rstrace");
c("quit");
End();
/* header */
Colon( "name," );
c("dup");
c("1+");
c("talign");
c("allot");
c("dup");
c("here");
c("1-");
c("c!");
c("here");
c("1-");
c("over");
c("-");
c("swap");
c("cmove");
End();
Colon( "header" );
c("name,");
c("link");
c("do-create");
c(",");
End();
Colon( "create" );
c("parse-word");
c("header");
End();
Colon( "codefield" ); /* ( codefield -- ) */
c("lastacf");
c("!");
End();
Colon( ":" );
c("create");
c("hide");
c("do-colon");
c("codefield");
c("]");
End();
Colon( ";" );
c("compile");
c("unnest");
c("[");
c("reveal");
End();
immediate();
}
static Ret translate_one(interpreter_interface* interface, Inputs... rest, LiteralList& args, int offset) {
auto& last = args.at(offset);
auto native = convert_literal_to_native<Input>(last);
return Then(interface, native, rest..., args, (uint32_t)offset - 1);
};
virtual void Run()
{
Given("an entity component store with added entities and with components", [&]()
{
m_entityComponentStore = ecs::EntityComponentStore<int>();
m_actualEntities = std::vector<int>();
m_entities = { 1, 2, 3, 4, 5 };
for (auto entity : m_entities)
m_entityComponentStore.addEntity(entity);
m_entitiesWithStringComponent.push_back(m_entities[2]);
m_entitiesWithIntComponent.push_back(m_entities[2]);
m_entitiesWithIntComponent.push_back(m_entities[3]);
m_expectedStringComponentValue = std::string("test_component1");
m_expectedIntComponentValue = 7;
for (auto entity : m_entitiesWithStringComponent)
m_entityComponentStore.addComponent(entity, m_expectedStringComponentValue);
for (auto entity : m_entitiesWithIntComponent)
m_entityComponentStore.addComponent(entity, m_expectedIntComponentValue);
});
Then("getting the string component of an entity gives the expected value", [&]()
{
std::string component = m_entityComponentStore.getComponentOfEntity<std::string>(m_entitiesWithStringComponent[0]);
AssertThat(component, ut11::Is::EqualTo(m_expectedStringComponentValue));
});
Then("getting the int component of an entity gives the expected value", [&]()
{
int component = m_entityComponentStore.getComponentOfEntity<int>(m_entitiesWithIntComponent[0]);
AssertThat(component, ut11::Is::EqualTo(m_expectedIntComponentValue));
});
Then("getting a component of an entity that does not exist throws the expected exception", [&]()
{
AssertThat([&]() { m_entityComponentStore.getComponentOfEntity<std::string>(100); }, ut11::Will::Throw<ecs::EntityNotFoundException>());
});
Then("getting a component of an entity that does not have that component throws the expected exception", [&]()
{
AssertThat([&]() { m_entityComponentStore.getComponentOfEntity<std::string>(m_entities[4]); }, ut11::Will::Throw<ecs::ComponentNotFoundException>());
});
When("getting all entities", [&]()
{
m_actualEntities = m_entityComponentStore.getAllEntities();
});
Then("the expected entities are returned", [&]()
{
AssertThat(m_actualEntities, ut11::Is::Iterable::EquivalentTo(m_entities));
});
When("getting all entities with string components", [&]()
{
m_actualEntities = m_entityComponentStore.getAllEntitiesFor<std::string>();
});
Then("the expected entities are returned", [&]()
{
AssertThat(m_actualEntities, ut11::Is::Iterable::EquivalentTo(m_entitiesWithStringComponent));
});
When("getting all entities with int components", [&]()
{
m_actualEntities = m_entityComponentStore.getAllEntitiesFor<int>();
});
Then("the expected entities are returned", [&]()
{
AssertThat(m_actualEntities, ut11::Is::Iterable::EquivalentTo(m_entitiesWithIntComponent));
});
}
virtual void Run()
{
Given("an output stream and output", [&]()
{
m_actualOutput.str("");
m_output = std::unique_ptr<ut11::out::StdOutput>(new ut11::out::StdOutput(m_actualOutput));
});
When("begin and end without running any tests", [&]()
{
m_output->Begin();
m_output->Finish(10, 7);
});
Then("the output is as expected", [&]()
{
AssertThat(m_actualOutput.str(), ut11::Is::EqualTo("\nFinished!\nRan: 10\nSucceeded: 7\n"));
});
When("running a test fixture with just a Then", [&]()
{
m_output->Begin();
m_output->BeginFixture("fixture");
m_output->BeginTest();
m_output->BeginThen("then");
m_output->EndThen("then");
m_output->EndTest();
m_output->EndFixture("fixture");
m_output->Finish(1, 1);
});
Then("the output is as expected", [&]()
{
auto stringVal = m_actualOutput.str();
auto startOfTime = stringVal.find('[');
auto endOfTime = stringVal.find(']');
stringVal = stringVal.erase(startOfTime, endOfTime - startOfTime + 1);
AssertThat(stringVal, ut11::Is::EqualTo("Fixture: fixture\n\t\t\tThen: then \n\nFinished!\nRan: 1\nSucceeded: 1\n"));
});
When("running two test fixtures with just a Then", [&]()
{
m_output->Begin();
m_output->BeginFixture("fixture");
m_output->BeginTest();
m_output->BeginThen("then");
m_output->EndThen("then");
m_output->EndTest();
m_output->EndFixture("fixture");
m_output->BeginFixture("fixture2");
m_output->BeginTest();
m_output->BeginThen("then2");
m_output->EndThen("then2");
m_output->EndTest();
m_output->EndFixture("fixture2");
m_output->Finish(2, 2);
});
Then("the output is as expected", [&]()
{
auto stringVal = m_actualOutput.str();
auto startOfTime = stringVal.find('[');
auto endOfTime = stringVal.find(']');
stringVal = stringVal.erase(startOfTime, endOfTime - startOfTime + 1);
startOfTime = stringVal.find('[');
endOfTime = stringVal.find(']');
stringVal = stringVal.erase(startOfTime, endOfTime - startOfTime + 1);
AssertThat(stringVal, ut11::Is::EqualTo("Fixture: fixture\n\t\t\tThen: then \nFixture: fixture2\n\t\t\tThen: then2 \n\nFinished!\nRan: 2\nSucceeded: 2\n"));
});
When("running a test fixture with just a When and Then", [&]()
{
m_output->Begin();
m_output->BeginFixture("fixture");
m_output->BeginTest();
m_output->BeginWhen("when");
m_output->EndWhen("then");
m_output->BeginThen("then");
m_output->EndThen("then");
m_output->EndTest();
m_output->EndFixture("fixture");
m_output->Finish(1, 1);
});
Then("the output is as expected", [&]()
{
auto stringVal = m_actualOutput.str();
auto startOfTime = stringVal.find('[');
auto endOfTime = stringVal.find(']');
stringVal = stringVal.erase(startOfTime, endOfTime - startOfTime + 1);
AssertThat(stringVal, ut11::Is::EqualTo("Fixture: fixture\n\t\tWhen: when\n\t\t\tThen: then \n\nFinished!\nRan: 1\nSucceeded: 1\n"));
});
When("running a test fixture with a Given When and Then", [&]()
{
m_output->Begin();
m_output->BeginFixture("fixture");
m_output->BeginTest();
m_output->BeginGiven("given");
m_output->EndGiven("given");
m_output->BeginWhen("when");
m_output->EndWhen("then");
m_output->BeginThen("then");
m_output->EndThen("then");
m_output->EndTest();
m_output->EndFixture("fixture");
m_output->Finish(1, 1);
});
Then("the output is as expected", [&]()
{
auto stringVal = m_actualOutput.str();
auto startOfTime = stringVal.find('[');
auto endOfTime = stringVal.find(']');
stringVal = stringVal.erase(startOfTime, endOfTime - startOfTime + 1);
AssertThat(stringVal, ut11::Is::EqualTo("Fixture: fixture\n\tGiven: given\n\t\tWhen: when\n\t\t\tThen: then \n\nFinished!\nRan: 1\nSucceeded: 1\n"));
});
When("running a test fixture with a Given When Then Finally", [&]()
{
m_output->Begin();
m_output->BeginFixture("fixture");
m_output->BeginTest();
m_output->BeginGiven("given");
m_output->EndGiven("given");
m_output->BeginWhen("when");
m_output->EndWhen("then");
m_output->BeginThen("then");
m_output->EndThen("then");
m_output->BeginFinally("finally");
m_output->EndFinally("finally");
m_output->EndTest();
m_output->EndFixture("fixture");
m_output->Finish(1, 1);
});
Then("the output is as expected", [&]()
{
auto stringVal = m_actualOutput.str();
auto startOfTime = stringVal.find('[');
auto endOfTime = stringVal.find(']');
stringVal = stringVal.erase(startOfTime, endOfTime - startOfTime + 1);
AssertThat(stringVal, ut11::Is::EqualTo("Fixture: fixture\n\tGiven: given\n\t\tWhen: when\n\t\t\tThen: then \n\tFinally: finally\n\nFinished!\nRan: 1\nSucceeded: 1\n"));
});
When("running a test fixture with multiple tests with a Given When Then Finally where the Given and Whens repeat", [&]()
{
m_output->Begin();
m_output->BeginFixture("fixture");
m_output->BeginTest();
m_output->BeginGiven("given");
m_output->EndGiven("given");
m_output->BeginWhen("when");
m_output->EndWhen("then");
m_output->BeginThen("then");
m_output->EndThen("then");
m_output->BeginFinally("finally");
m_output->EndFinally("finally");
m_output->EndTest();
m_output->BeginTest();
m_output->BeginGiven("given");
m_output->EndGiven("given");
m_output->BeginWhen("when");
m_output->EndWhen("then");
m_output->BeginThen("then2");
m_output->EndThen("then2");
m_output->BeginFinally("finally");
m_output->EndFinally("finally");
m_output->EndTest();
m_output->EndFixture("fixture");
m_output->Finish(1, 1);
});
Then("the output is as expected", [&]()
{
auto stringVal = m_actualOutput.str();
auto startOfTime = stringVal.find('[');
auto endOfTime = stringVal.find(']');
stringVal = stringVal.erase(startOfTime, endOfTime - startOfTime + 1);
startOfTime = stringVal.find('[');
endOfTime = stringVal.find(']');
stringVal = stringVal.erase(startOfTime, endOfTime - startOfTime + 1);
AssertThat(stringVal, ut11::Is::EqualTo("Fixture: fixture\n\tGiven: given\n\t\tWhen: when\n\t\t\tThen: then \n\t\t\tThen: then2 \n\tFinally: finally\n\nFinished!\nRan: 1\nSucceeded: 1\n"));
});
When("running a test fixture with a When Then Finally", [&]()
{
m_output->Begin();
m_output->BeginFixture("fixture");
m_output->BeginTest();
m_output->BeginWhen("when");
m_output->EndWhen("then");
m_output->BeginThen("then");
m_output->EndThen("then");
m_output->BeginFinally("finally");
m_output->EndFinally("finally");
m_output->EndTest();
m_output->EndFixture("fixture");
m_output->Finish(1, 1);
});
Then("the output is as expected", [&]()
{
auto stringVal = m_actualOutput.str();
auto startOfTime = stringVal.find('[');
auto endOfTime = stringVal.find(']');
stringVal = stringVal.erase(startOfTime, endOfTime - startOfTime + 1);
AssertThat(stringVal, ut11::Is::EqualTo("Fixture: fixture\n\t\tWhen: when\n\t\t\tThen: then \n\tFinally: finally\n\nFinished!\nRan: 1\nSucceeded: 1\n"));
});
When("running a test fixture with a Then Finally", [&]()
{
m_output->Begin();
m_output->BeginFixture("fixture");
m_output->BeginTest();
m_output->BeginThen("then");
m_output->EndThen("then");
m_output->BeginFinally("finally");
m_output->EndFinally("finally");
m_output->EndTest();
m_output->EndFixture("fixture");
m_output->Finish(1, 1);
});
Then("the output is as expected", [&]()
{
auto stringVal = m_actualOutput.str();
auto startOfTime = stringVal.find('[');
auto endOfTime = stringVal.find(']');
stringVal = stringVal.erase(startOfTime, endOfTime - startOfTime + 1);
AssertThat(stringVal, ut11::Is::EqualTo("Fixture: fixture\n\t\t\tThen: then \n\tFinally: finally\n\nFinished!\nRan: 1\nSucceeded: 1\n"));
});
When("running a test fixture with a Given When Then Finally and the Then fails with an std::exception", [&]()
{
m_output->Begin();
m_output->BeginFixture("fixture");
m_output->BeginTest();
m_output->BeginGiven("given");
m_output->EndGiven("given");
m_output->BeginWhen("when");
m_output->EndWhen("then");
m_output->BeginThen("then");
m_output->OnError(std::runtime_error("error"));
m_output->EndThen("then");
m_output->BeginFinally("finally");
m_output->EndFinally("finally");
m_output->EndTest();
m_output->EndFixture("fixture");
m_output->Finish(1, 0);
});
Then("the output is as expected", [&]()
{
auto stringVal = m_actualOutput.str();
auto startOfTime = stringVal.find('[');
startOfTime = stringVal.substr(startOfTime + 1).find('[') + startOfTime;
auto endOfTime = stringVal.find(']');
endOfTime = stringVal.substr(endOfTime + 1).find(']') + endOfTime + 1;
stringVal = stringVal.erase(startOfTime, endOfTime - startOfTime + 1);
AssertThat(stringVal, ut11::Is::EqualTo("Fixture: fixture\n\tGiven: given\n\t\tWhen: when\n\t\t\tThen: then\n\tFailed: std::exception was thrown [what(): error]\n\tFinally: finally\n\nFinished!\nRan: 1\nSucceeded: 0\n"));
});
When("running a test fixture with a Given When Then Finally and the Then fails with an unknown error", [&]()
{
m_output->Begin();
m_output->BeginFixture("fixture");
m_output->BeginTest();
m_output->BeginGiven("given");
m_output->EndGiven("given");
m_output->BeginWhen("when");
m_output->EndWhen("then");
m_output->BeginThen("then");
m_output->OnUnknownError();
m_output->EndThen("then");
m_output->BeginFinally("finally");
m_output->EndFinally("finally");
m_output->EndTest();
m_output->EndFixture("fixture");
m_output->Finish(1, 0);
});
Then("the output is as expected", [&]()
{
auto stringVal = m_actualOutput.str();
auto startOfTime = stringVal.find('[');
startOfTime = stringVal.substr(startOfTime + 1).find('[') + startOfTime;
auto endOfTime = stringVal.find(']');
endOfTime = stringVal.substr(endOfTime + 1).find(']') + endOfTime + 1;
stringVal = stringVal.erase(startOfTime, endOfTime - startOfTime + 1);
AssertThat(stringVal, ut11::Is::EqualTo("Fixture: fixture\n\tGiven: given\n\t\tWhen: when\n\t\t\tThen: then\n\tFailed: Unknown Error\n\tFinally: finally\n\nFinished!\nRan: 1\nSucceeded: 0\n"));
});
When("running a test fixture with a Given When Then Finally and the Then fails", [&]()
{
m_output->Begin();
m_output->BeginFixture("fixture");
m_output->BeginTest();
m_output->BeginGiven("given");
m_output->EndGiven("given");
m_output->BeginWhen("when");
m_output->EndWhen("then");
m_output->BeginThen("then");
m_output->OnError(10, "file", "error");
m_output->EndThen("then");
m_output->BeginFinally("finally");
m_output->EndFinally("finally");
m_output->EndTest();
m_output->EndFixture("fixture");
m_output->Finish(1, 0);
});
Then("the output is as expected", [&]()
{
auto stringVal = m_actualOutput.str();
auto startOfTime = stringVal.find('[');
startOfTime = stringVal.substr(startOfTime + 1).find('[') + startOfTime;
auto endOfTime = stringVal.find(']');
endOfTime = stringVal.substr(endOfTime + 1).find(']') + endOfTime + 1;
stringVal = stringVal.erase(startOfTime, endOfTime - startOfTime + 1);
AssertThat(stringVal, ut11::Is::EqualTo("Fixture: fixture\n\tGiven: given\n\t\tWhen: when\n\t\t\tThen: then\n\tFailed: [10:file] error\n\tFinally: finally\n\nFinished!\nRan: 1\nSucceeded: 0\n"));
});
When("running a test fixture with a Given When Finally and the When fails", [&]()
{
m_output->Begin();
m_output->BeginFixture("fixture");
m_output->BeginTest();
m_output->BeginGiven("given");
m_output->EndGiven("given");
m_output->BeginWhen("when");
m_output->OnError(10, "file", "error");
m_output->EndWhen("then");
m_output->BeginFinally("finally");
m_output->EndFinally("finally");
m_output->EndTest();
m_output->EndFixture("fixture");
m_output->Finish(1, 0);
});
Then("the output is as expected", [&]()
{
auto stringVal = m_actualOutput.str();
auto startOfTime = stringVal.find('[');
startOfTime = stringVal.substr(startOfTime + 1).find('[') + startOfTime;
auto endOfTime = stringVal.find(']');
endOfTime = stringVal.substr(endOfTime + 1).find(']') + endOfTime + 1;
stringVal = stringVal.erase(startOfTime, endOfTime - startOfTime + 1);
AssertThat(stringVal, ut11::Is::EqualTo("Fixture: fixture\n\tGiven: given\n\t\tWhen: when\n\tFailed: [10:file] error\n\tFinally: finally\n\nFinished!\nRan: 1\nSucceeded: 0\n"));
});
When("running a test fixture with a Given Finally and the Given fails", [&]()
{
m_output->Begin();
m_output->BeginFixture("fixture");
m_output->BeginTest();
m_output->BeginGiven("given");
m_output->OnError(10, "file", "error");
m_output->EndGiven("given");
m_output->BeginFinally("finally");
m_output->EndFinally("finally");
m_output->EndTest();
m_output->EndFixture("fixture");
m_output->Finish(1, 0);
});
Then("the output is as expected", [&]()
{
auto stringVal = m_actualOutput.str();
auto startOfTime = stringVal.find('[');
startOfTime = stringVal.substr(startOfTime + 1).find('[') + startOfTime;
auto endOfTime = stringVal.find(']');
endOfTime = stringVal.substr(endOfTime + 1).find(']') + endOfTime + 1;
stringVal = stringVal.erase(startOfTime, endOfTime - startOfTime + 1);
AssertThat(stringVal, ut11::Is::EqualTo("Fixture: fixture\n\tGiven: given\n\tFailed: [10:file] error\n\tFinally: finally\n\nFinished!\nRan: 1\nSucceeded: 0\n"));
});
When("running a test fixture with a Given Finally and the Finally fails", [&]()
{
m_output->Begin();
m_output->BeginFixture("fixture");
m_output->BeginTest();
m_output->BeginGiven("given");
m_output->EndGiven("given");
m_output->BeginFinally("finally");
m_output->OnError(10, "file", "error");
m_output->EndFinally("finally");
m_output->EndTest();
m_output->EndFixture("fixture");
m_output->Finish(1, 0);
});
Then("the output is as expected", [&]()
{
auto stringVal = m_actualOutput.str();
auto startOfTime = stringVal.find('[');
startOfTime = stringVal.substr(startOfTime + 1).find('[') + startOfTime;
auto endOfTime = stringVal.find(']');
endOfTime = stringVal.substr(endOfTime + 1).find(']') + endOfTime + 1;
stringVal = stringVal.erase(startOfTime, endOfTime - startOfTime + 1);
AssertThat(stringVal, ut11::Is::EqualTo("Fixture: fixture\n\tGiven: given\n\tFinally: finally\n\tFailed: [10:file] error\n\nFinished!\nRan: 1\nSucceeded: 0\n"));
});
}
static Ret translate_one(interpreter_interface* interface, Inputs... rest, LiteralList& args, int offset) {
uint32_t ptr = args.at((uint32_t)offset).geti32();
return Then(interface, null_terminated_ptr_impl(interface, ptr), rest..., args, (uint32_t)offset - 1);
};
static Ret translate_one(interpreter_interface* interface, LiteralList& args, int offset) {
uint32_t ptr = args.at((uint32_t)offset - 2).geti32();
uint32_t value = args.at((uint32_t)offset - 1).geti32();
size_t length = args.at((uint32_t)offset).geti32();
return Then(interface, array_ptr_impl<char>(interface, ptr, length), value, length, args, (uint32_t)offset - 3);
};
static Ret translate_one(interpreter_interface* interface, Inputs... rest, LiteralList& args, int offset) {
uint32_t wasm_value = args.at((uint32_t)offset).geti32();
auto value = fc::time_point_sec(wasm_value);
return Then(interface, value, rest..., args, (uint32_t)offset - 1);
}
already_AddRefed<Promise>
Promise::Catch(const Optional<OwningNonNull<AnyCallback> >& aRejectCallback)
{
Optional<OwningNonNull<AnyCallback> > resolveCb;
return Then(resolveCb, aRejectCallback);
}
virtual void Run(){
Given("a MockReturnHandler", [&]() {
m_returner = ut11::detail::MockReturnHandler<int, char>();
});
When("calling the MockReturnHandler", [&]() {
m_expectedReturnValue = ut11::utility::DefaultValue<int>()();
m_returnedValue = m_returner.operator ()('A');
});
Then("the return value is the expected value", [&]() {
AssertThat(m_returnedValue, ut11::Is::EqualTo(m_expectedReturnValue));
});
When("setting the value to be returned and calling the MockReturnHandler", [&]() {
m_expectedReturnValue = 32;
m_returner.SetReturn(m_expectedReturnValue);
m_returnedValue = m_returner.operator ()('A');
});
Then("the return value is the expected value", [&]() {
AssertThat(m_returnedValue, ut11::Is::EqualTo(m_expectedReturnValue));
});
When("setting the a return function and calling the MockReturnHandler", [&]() {
m_expectedReturnValue = 32;
m_expectedArgument = 'Z';
m_returner.SetReturn([&](char actual)
{
m_actualArgument = actual;
return m_expectedReturnValue;
});
m_returnedValue = m_returner.operator ()(m_expectedArgument);
});
Then("the return value is the expected value", [&]() {
AssertThat(m_returnedValue, ut11::Is::EqualTo(m_expectedReturnValue));
});
Then("the argument passed in to the return function is the expected value", [&]() {
AssertThat(m_actualArgument, ut11::Is::EqualTo(m_expectedArgument));
});
When("setting the a return value, overriding that with a return function and calling the MockReturnHandler", [&]() {
m_expectedReturnValue = 32;
m_expectedArgument = 'Z';
m_returner.SetReturn('A');
m_returner.SetReturn([&](char actual)
{
m_actualArgument = actual;
return m_expectedReturnValue;
});
m_returnedValue = m_returner.operator ()(m_expectedArgument);
});
Then("the return value is the expected value", [&]() {
AssertThat(m_returnedValue, ut11::Is::EqualTo(m_expectedReturnValue));
});
Then("the argument passed in to the return function is the expected value", [&]() {
AssertThat(m_actualArgument, ut11::Is::EqualTo(m_expectedArgument));
});
When("setting the a return function, overriding that with a return value and calling the MockReturnHandler", [&]() {
m_expectedReturnValue = 32;
m_returner.SetReturn([&](char) { return 21; });
m_returner.SetReturn(m_expectedReturnValue);
m_returnedValue = m_returner.operator ()(m_expectedArgument);
});
Then("the return value is the expected value", [&]() {
AssertThat(m_returnedValue, ut11::Is::EqualTo(m_expectedReturnValue));
});
}
