void
test_set_variable (struct EventFixture *ef, const void *data) {
(void) data;
/* set a string */
parse_cmd_line("set useragent = Uzbl browser kthxbye!", NULL);
ASSERT_EVENT(ef, "VARIABLE_SET useragent str 'Uzbl browser kthxbye!'");
g_assert_cmpstr("Uzbl browser kthxbye!", ==, uzbl.net.useragent);
/* set an int */
parse_cmd_line("set forward_keys = 0", NULL);
ASSERT_EVENT(ef, "VARIABLE_SET forward_keys int 0");
g_assert_cmpint(0, ==, uzbl.behave.forward_keys);
/* set a float */
/* we have to be careful about locales here */
GString *cmd;
cmd = g_string_new("set zoom_level = ");
g_string_append_printf(cmd, "%f", 0.25);
parse_cmd_line(g_string_free(cmd, FALSE), NULL);
ASSERT_EVENT(ef, "VARIABLE_SET zoom_level float 0.25");
g_assert_cmpfloat(0.25, ==, get_var_value_float("zoom_level"));
/* set a constant int (nothing should happen) */
int old_major = uzbl.info.webkit_major;
parse_cmd_line("set WEBKIT_MAJOR = 100", NULL);
assert_no_event(ef);
g_assert_cmpint(old_major, ==, uzbl.info.webkit_major);
/* set a constant str (nothing should happen) */
GString *old_arch = g_string_new(uzbl.info.arch);
parse_cmd_line("set ARCH_UZBL = A Lisp Machine", NULL);
assert_no_event(ef);
g_assert_cmpstr(g_string_free(old_arch, FALSE), ==, uzbl.info.arch);
/* set a custom variable */
parse_cmd_line("set nonexistant_variable = Some Value", NULL);
ASSERT_EVENT(ef, "VARIABLE_SET nonexistant_variable str 'Some Value'");
uzbl_cmdprop *c = g_hash_table_lookup(uzbl.behave.proto_var, "nonexistant_variable");
g_assert_cmpstr("Some Value", ==, *(c->ptr.s));
/* set a custom variable with expansion */
parse_cmd_line("set an_expanded_variable = Test @(echo expansion)@", NULL);
ASSERT_EVENT(ef, "VARIABLE_SET an_expanded_variable str 'Test expansion'");
c = g_hash_table_lookup(uzbl.behave.proto_var, "an_expanded_variable");
g_assert_cmpstr("Test expansion", ==, *(c->ptr.s));
}
LONG
KeReadStateEvent (
IN PRKEVENT Event
)
/*++
Routine Description:
This function reads the current signal state of an event object.
Arguments:
Event - Supplies a pointer to a dispatcher object of type event.
Return Value:
The current signal state of the event object.
--*/
{
ASSERT_EVENT(Event);
//
// Return current signal state of event object.
//
return Event->Header.SignalState;
}
VOID
KeClearEvent (
IN PRKEVENT Event
)
/*++
Routine Description:
This function clears the signal state of an event object.
Arguments:
Event - Supplies a pointer to a dispatcher object of type event.
Return Value:
None.
--*/
{
ASSERT_EVENT(Event);
//
// Clear signal state of event object.
//
Event->Header.SignalState = 0;
return;
}
/*
* @implemented
*/
VOID
NTAPI
KeClearEvent(IN PKEVENT Event)
{
ASSERT_EVENT(Event);
/* Reset Signal State */
Event->Header.SignalState = FALSE;
}
/*
* @implemented
*/
LONG
NTAPI
KeReadStateEvent(IN PKEVENT Event)
{
ASSERT_EVENT(Event);
/* Return the Signal State */
return Event->Header.SignalState;
}
LONG
KeResetEvent (
IN PRKEVENT Event
)
/*++
Routine Description:
This function resets the signal state of an event object to
Not-Signaled. The previous state of the event object is returned
as the function value.
Arguments:
Event - Supplies a pointer to a dispatcher object of type event.
Return Value:
The previous signal state of the event object.
--*/
{
KIRQL OldIrql;
LONG OldState;
ASSERT_EVENT(Event);
ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
//
// Raise IRQL to dispatcher level and lock dispatcher database.
//
KiLockDispatcherDatabase(&OldIrql);
//
// Capture the current signal state of event object and then reset
// the state of the event object to Not-Signaled.
//
OldState = Event->Header.SignalState;
Event->Header.SignalState = 0;
//
// Unlock the dispatcher database and lower IRQL to its previous
// value.
KiUnlockDispatcherDatabase(OldIrql);
//
// Return previous signal state of event object.
//
return OldState;
}
void
test_event (struct EventFixture *ef, const void *data) {
(void) data;
parse_cmd_line("event", NULL);
assert_no_event(ef);
/* a simple event can be sent */
parse_cmd_line("event event_type arg u ments", NULL);
ASSERT_EVENT(ef, "EVENT_TYPE arg u ments");
/* arguments to event should be expanded */
parse_cmd_line("event event_type @(echo expansion)@ test", NULL);
ASSERT_EVENT(ef, "EVENT_TYPE expansion test");
/* "request" is just an alias for "event" */
parse_cmd_line("request event_type arg u ments", NULL);
ASSERT_EVENT(ef, "EVENT_TYPE arg u ments");
}
/*
* @implemented
*/
LONG
NTAPI
KePulseEvent(IN PKEVENT Event,
IN KPRIORITY Increment,
IN BOOLEAN Wait)
{
KIRQL OldIrql;
LONG PreviousState;
PKTHREAD Thread;
ASSERT_EVENT(Event);
ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
/* Lock the Dispatcher Database */
OldIrql = KiAcquireDispatcherLock();
/* Save the Old State */
PreviousState = Event->Header.SignalState;
/* Check if we are non-signaled and we have stuff in the Wait Queue */
if (!PreviousState && !IsListEmpty(&Event->Header.WaitListHead))
{
/* Set the Event to Signaled */
Event->Header.SignalState = 1;
/* Wake the Event */
KiWaitTest(&Event->Header, Increment);
}
/* Unsignal it */
Event->Header.SignalState = 0;
/* Check what wait state was requested */
if (Wait == FALSE)
{
/* Wait not requested, release Dispatcher Database and return */
KiReleaseDispatcherLock(OldIrql);
}
else
{
/* Return Locked and with a Wait */
Thread = KeGetCurrentThread();
Thread->WaitNext = TRUE;
Thread->WaitIrql = OldIrql;
}
/* Return the previous State */
return PreviousState;
}
/*
* @implemented
*/
LONG
NTAPI
KeResetEvent(IN PKEVENT Event)
{
KIRQL OldIrql;
LONG PreviousState;
ASSERT_EVENT(Event);
ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
/* Lock the Dispatcher Database */
OldIrql = KiAcquireDispatcherLock();
/* Save the Previous State */
PreviousState = Event->Header.SignalState;
/* Set it to zero */
Event->Header.SignalState = 0;
/* Release Dispatcher Database and return previous state */
KiReleaseDispatcherLock(OldIrql);
return PreviousState;
}
/*
* @implemented
*/
LONG
NTAPI
KeSetEvent(IN PKEVENT Event,
IN KPRIORITY Increment,
IN BOOLEAN Wait)
{
KIRQL OldIrql;
LONG PreviousState;
PKTHREAD Thread;
ASSERT_EVENT(Event);
ASSERT_IRQL_LESS_OR_EQUAL(DISPATCH_LEVEL);
/*
* Check if this is an signaled notification event without an upcoming wait.
* In this case, we can immediately return TRUE, without locking.
*/
if ((Event->Header.Type == EventNotificationObject) &&
(Event->Header.SignalState == 1) &&
!(Wait))
{
/* Return the signal state (TRUE/Signalled) */
return TRUE;
}
/* Lock the Dispathcer Database */
OldIrql = KiAcquireDispatcherLock();
/* Save the Previous State */
PreviousState = Event->Header.SignalState;
/* Set the Event to Signaled */
Event->Header.SignalState = 1;
/* Check if the event just became signaled now, and it has waiters */
if (!(PreviousState) && !(IsListEmpty(&Event->Header.WaitListHead)))
{
/* Check the type of event */
if (Event->Header.Type == EventNotificationObject)
{
/* Unwait the thread */
KxUnwaitThread(&Event->Header, Increment);
}
else
{
/* Otherwise unwait the thread and unsignal the event */
KxUnwaitThreadForEvent(Event, Increment);
}
}
/* Check what wait state was requested */
if (!Wait)
{
/* Wait not requested, release Dispatcher Database and return */
KiReleaseDispatcherLock(OldIrql);
}
else
{
/* Return Locked and with a Wait */
Thread = KeGetCurrentThread();
Thread->WaitNext = TRUE;
Thread->WaitIrql = OldIrql;
}
/* Return the previous State */
return PreviousState;
}
LONG
KeSetEvent (
IN PRKEVENT Event,
IN KPRIORITY Increment,
IN BOOLEAN Wait
)
/*++
Routine Description:
This function sets the signal state of an event object to Signaled
and attempts to satisfy as many Waits as possible. The previous
signal state of the event object is returned as the function value.
Arguments:
Event - Supplies a pointer to a dispatcher object of type event.
Increment - Supplies the priority increment that is to be applied
if setting the event causes a Wait to be satisfied.
Wait - Supplies a boolean value that signifies whether the call to
KePulseEvent will be immediately followed by a call to one of the
kernel Wait functions.
Return Value:
The previous signal state of the event object.
--*/
{
KIRQL OldIrql;
LONG OldState;
PRKTHREAD Thread;
ASSERT_EVENT(Event);
ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
//
// Collect call data.
//
#if defined(_COLLECT_SET_EVENT_CALLDATA_)
RECORD_CALL_DATA(&KiSetEventCallData);
#endif
//
// Raise IRQL to dispatcher level and lock dispatcher database.
//
KiLockDispatcherDatabase(&OldIrql);
//
// If the current state of the event object is not Signaled, the set the
// state of the event object to Signaled, and check for waiters.
//
OldState = Event->Header.SignalState;
Event->Header.SignalState = 1;
if ((OldState == 0) && (IsListEmpty(&Event->Header.WaitListHead) == FALSE)) {
KiWaitTest(Event, Increment);
}
//
// If the value of the Wait argument is TRUE, then return to the
// caller with IRQL raised and the dispatcher database locked. Else
// release the dispatcher database lock and lower IRQL to its
// previous value.
//
if (Wait != FALSE) {
Thread = KeGetCurrentThread();
Thread->WaitNext = Wait;
Thread->WaitIrql = OldIrql;
} else {
KiUnlockDispatcherDatabase(OldIrql);
}
//
// Return previous signal state of event object.
//
return OldState;
}
LONG
KeSetEvent (
__inout PRKEVENT Event,
__in KPRIORITY Increment,
__in BOOLEAN Wait
)
/*++
Routine Description:
This function sets the signal state of an event object to signaled
and attempts to satisfy as many waits as possible. The previous
signal state of the event object is returned as the function value.
Arguments:
Event - Supplies a pointer to a dispatcher object of type event.
Increment - Supplies the priority increment that is to be applied
if setting the event causes a Wait to be satisfied.
Wait - Supplies a boolean value that signifies whether the call to
set event will be immediately followed by a call to one of the
kernel Wait functions.
Return Value:
The previous signal state of the event object.
--*/
{
KIRQL OldIrql;
LONG OldState;
PRKTHREAD Thread;
ASSERT_EVENT(Event);
ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
//
// If the event is a notification event, the event is already signaled,
// and wait is false, then there is no need to set the event.
//
if ((Event->Header.Type == EventNotificationObject) &&
(Event->Header.SignalState == 1) &&
(Wait == FALSE)) {
return 1;
}
//
// Raise IRQL to dispatcher level and lock dispatcher database.
//
KiLockDispatcherDatabase(&OldIrql);
//
// Capture the old state and set the new state to signaled.
//
// If the old state is not-signaled and the wait list is not empty,
// then satisfy as many waits as possible.
//
OldState = ReadForWriteAccess(&Event->Header.SignalState);
Event->Header.SignalState = 1;
if ((OldState == 0) &&
(IsListEmpty(&Event->Header.WaitListHead) == FALSE)) {
if (Event->Header.Type == EventNotificationObject) {
KiWaitTestWithoutSideEffects(Event, Increment);
} else {
KiWaitTestSynchronizationObject(Event, Increment);
}
}
//
// If the value of the Wait argument is TRUE, then return to the
// caller with IRQL raised and the dispatcher database locked. Else
// release the dispatcher database lock and lower IRQL to its
// previous value.
//
if (Wait != FALSE) {
Thread = KeGetCurrentThread();
Thread->WaitNext = Wait;
Thread->WaitIrql = OldIrql;
} else {
KiUnlockDispatcherDatabase(OldIrql);
}
//
// Return previous signal state of event object.
//
return OldState;
}
LONG
KePulseEvent (
__inout PRKEVENT Event,
__in KPRIORITY Increment,
__in BOOLEAN Wait
)
/*++
Routine Description:
This function atomically sets the signal state of an event object to
signaled, attempts to satisfy as many waits as possible, and then resets
the signal state of the event object to Not-Signaled. The previous signal
state of the event object is returned as the function value.
Arguments:
Event - Supplies a pointer to a dispatcher object of type event.
Increment - Supplies the priority increment that is to be applied
if setting the event causes a Wait to be satisfied.
Wait - Supplies a boolean value that signifies whether the call to
KePulseEvent will be immediately followed by a call to one of the
kernel Wait functions.
Return Value:
The previous signal state of the event object.
--*/
{
KIRQL OldIrql;
LONG OldState;
PRKTHREAD Thread;
ASSERT_EVENT(Event);
ASSERT(KeGetCurrentIrql() <= DISPATCH_LEVEL);
//
// Raise IRQL to dispatcher level and lock dispatcher database.
//
KiLockDispatcherDatabase(&OldIrql);
//
// If the current state of the event object is Not-Signaled and
// the wait queue is not empty, then set the state of the event
// to Signaled, satisfy as many Waits as possible, and then reset
// the state of the event to Not-Signaled.
//
OldState = ReadForWriteAccess(&Event->Header.SignalState);
if ((OldState == 0) &&
(IsListEmpty(&Event->Header.WaitListHead) == FALSE)) {
Event->Header.SignalState = 1;
KiWaitTest(Event, Increment);
}
Event->Header.SignalState = 0;
//
// If the value of the Wait argument is TRUE, then return to the
// caller with IRQL raised and the dispatcher database locked. Else
// release the dispatcher database lock and lower IRQL to the
// previous value.
//
if (Wait != FALSE) {
Thread = KeGetCurrentThread();
Thread->WaitIrql = OldIrql;
Thread->WaitNext = Wait;
} else {
KiUnlockDispatcherDatabase(OldIrql);
}
//
// Return previous signal state of event object.
//
return OldState;
}
