Run `typos -w` [1] on the repository, and cherry-pick the good changes.
[1] https://github.com/crate-ci/typos
Change-Id: I995cf7d851cd7ff40e47767ffe14c03fbd2d23bb
Signed-off-by: Simon Marchi <simon.marchi@efficios.com>
Reviewed-on: https://review.lttng.org/c/babeltrace/+/11426
Tested-by: jenkins <jenkins@lttng.org>
Reviewed-by: Philippe Proulx <eeppeliteloop@gmail.com>
AS_IF([test "x$ax_cv___attribute__" != "xyes"],
[AC_MSG_ERROR([The compiler does not support __attribute__ extensions])])
-# Make sur we have pthread support
+# Make sure we have pthread support
AX_PTHREAD([], [AC_MSG_ERROR([Could not configure pthread support])])
# Checks for typedefs, structures, and compiler characteristics.
], [BABELTRACE_DEBUG_MODE=0])
-## ##
-## Optionnal features selection ##
-## ##
+## ##
+## Optional features selection ##
+## ##
# Python bindings
# Disabled by default
@attention
This module (component class development API) offers functions to
- programatically create component classes. To get the properties of
+ programmatically create component classes. To get the properties of
an existing component class, see \ref api-comp-cls.
A component class has <em>methods</em>. This module essentially
There are two ways to obtain a component class:
-- Create one programatically: see \ref api-comp-cls-dev.
+- Create one programmatically: see \ref api-comp-cls-dev.
- Borrow one from a \bt_plugin.
this method, then the next time your
\link api-msg-iter-cls-meth-next "next" method\endlink is called:
- - For each "active" \bt_stream at the seeked time point, you must
+ - For each "active" \bt_stream at the sought time point, you must
emit a \bt_sb_msg for this stream before you emit any other
message for this stream.
The stream beginning message must have a
\ref api-msg-sb-prop-cs "default clock snapshot" which corresponds
- to the seeked time point.
+ to the sought time point.
- - For each "active" \bt_pkt at the seeked time point, you must
+ - For each "active" \bt_pkt at the sought time point, you must
emit a \bt_pb_msg for this packet before you emit any other
message for this packet.
The packet beginning message must have a
\ref api-msg-pb-prop-cs "default clock snapshot" which corresponds
- to the seeked time point.
+ to the sought time point.
The \bt_name project recommends that this method executes fast
enough so as not to block an interactive application running on the
<h1>\anchor api-msg-mip Message Interchange Protocol</h1>
The <em>Message Interchange Protocol</em> (MIP) is the system of rules
-used by \bt_p_comp and \bt_p_msg_iter to exchance messages within a
+used by \bt_p_comp and \bt_p_msg_iter to exchange messages within a
trace processing graph.
The MIP covers everything related to messages and what they contain, as
argument):
@code{.unparsed}
--f -m meow --jus mix --kilo
+-f -m meow --just mix --kilo
@endcode
The original argument index of \c meow is 2 while the original
argument):
@code{.unparsed}
--f -m meow --jus mix --kilo
+-f -m meow --just mix --kilo
@endcode
The non-option index of \c meow is 0 while the original
const bt_component_class_source *source;
const bt_plugin *plugin;
const bt_value *group;
- double weigth;
+ double weight;
} winner = { NULL, NULL, NULL, 0 };
if (interrupter && bt_interrupter_is_set(interrupter)) {
bt_plugin_get_name(plugin), bt_component_class_get_name(cc), input,
input_type, weight, group_value ? bt_value_string_get(group_value) : "(none)");
- if (weight > winner.weigth) {
+ if (weight > winner.weight) {
winner.source = source_cc;
winner.plugin = plugin;
winner.group = group_value;
bt_value_get_ref(winner.group);
- winner.weigth = weight;
+ winner.weight = weight;
}
} else if (query_status == BT_QUERY_EXECUTOR_QUERY_STATUS_ERROR) {
BT_AUTODISC_LOGE_APPEND_CAUSE("babeltrace.support-info query failed.");
group = winner.group ? bt_value_string_get(winner.group) : NULL;
BT_LOGI("Input awarded: input=%s, type=%s, component-class-name=source.%s.%s, weight=%f, group=%s",
- input, input_type, plugin_name, source_name, winner.weigth, group ? group : "(none)");
+ input, input_type, plugin_name, source_name, winner.weight, group ? group : "(none)");
status = auto_source_discovery_add(auto_disc, plugin_name,
source_name, group, input, original_input_index, log_level);
raise bt2_utils.Stop
def _bt_next_from_native(self):
- # this can raise anything: it's catched by the native part
+ # this can raise anything: it's caught by the native part
try:
msg = next(self)
except StopIteration:
module_name = "bt_plugin_{}".format(h.hexdigest())
assert module_name not in sys.modules
- # try loading the module: any raised exception is catched by the caller
+ # try loading the module: any raised exception is caught by the caller
if sys.version_info < (3, 5):
mod = importlib.machinery.SourceFileLoader(module_name, path).load_module()
else:
# distutils performs a similar transformation step on LDSHARED on
-# darwin to use the overriden CC as the default command for LDSHARED
+# darwin to use the overridden CC as the default command for LDSHARED
# (see distutils' customize_compiler() step in the sysconfig module).
#
# This takes it a step further by using our own LDFLAGS (when available)
-# along with the overriden compiler and ensure that flags that are unsupported
-# by either the Python interprter's CC or the overriden CC don't cause a
+# along with the overridden compiler and ensure that flags that are unsupported
+# by either the Python interprter's CC or the overridden CC don't cause a
# build failure.
def get_ldshared():
cc = os.environ.get("CC")
g_setenv("LIBBABELTRACE2_PLUGIN_PROVIDER_DIR", CONFIG_IN_TREE_PROVIDER_DIR, 0);
#else
/*
- * If the Pyhton plugin provider is disabled, use a non-exitent path to avoid
+ * If the Python plugin provider is disabled, use a non-exitent path to avoid
* loading the system installed provider if it exit, if the env variable is
* already set, do not overwrite it.
*/
/*
* Adds the digit separator `sep` as many times as needed to form groups
* of `digits_per_group` digits within `str`. `str` must have enough
- * room to accomodate the new separators, that is:
+ * room to accommodate the new separators, that is:
*
* strlen(str) + (strlen(str) / digits_per_group) + 1
*
* `CommonMapValueForEachUserFunc<ObjT>` (the user function to call).
*
* This function catches any exception which the user function throws
- * and returns the `ErrorStatus` value. If there's no execption, this
+ * and returns the `ErrorStatus` value. If there's no exception, this
* function returns the `OkStatus` value.
*/
template <typename ObjT, typename LibObjT, typename LibStatusT, int OkStatus, int ErrorStatus>
/*
* A type can't be modified once it is added to an event or after a
- * a field has been instanciated from it.
+ * a field has been instantiated from it.
*/
int frozen;
ret = bt_ctf_field_type_common_variant_set_tag_field_path(
type, target_field_path);
if (ret) {
- BT_LOGW("Cannot set varaint field type's tag field path: "
+ BT_LOGW("Cannot set variant field type's tag field path: "
"ret=%d, ft-addr=%p, path=\"%s\", target-field-path=\"%s\"",
ret, type, pathstr,
target_field_path_pretty_str);
ret = bt_ctf_field_type_common_variant_set_tag_field_type(
type, target_type);
if (ret) {
- BT_LOGW("Cannot set varaint field type's tag field type: "
+ BT_LOGW("Cannot set variant field type's tag field type: "
"ret=%d, ft-addr=%p, path=\"%s\", target-field-path=\"%s\"",
ret, type, pathstr,
target_field_path_pretty_str);
* The reference to the trace is only borrowed since the
* serialization of the stream class might have been triggered
* by the trace's destruction. In such a case, the trace's
- * reference count would, unexepectedly, go through the sequence
+ * reference count would, unexpectedly, go through the sequence
* 1 -> 0 -> 1 -> 0 -> ..., provoking an endless loop of destruction
* and serialization.
*/
* Returns the following codes:
* 1 if the field was found and set,
* 0 if nothing was done (field not found, or was already set),
- * <0 if an error was encoutered
+ * <0 if an error was encountered
*/
static
int try_set_structure_field_integer(struct bt_ctf_field *structure, const char *name,
# Fetch the BT_VERSION_EXTRA_DESCRIPTION define from "version/extra_version_description",
# sanitize and format it with a sed script to replace all non-alpha-numeric values
- # with "-" and join all lines by replacing "\n" with litteral string c-style "\n" and
+ # with "-" and join all lines by replacing "\n" with literal string c-style "\n" and
# output it to "version.i.tmp".
echo "#define BT_VERSION_EXTRA_DESCRIPTION \"$($SED -E ':a ; N ; $!ba ; s/[^a-zA-Z0-9 \n\t\.,]/-/g ; s/\r{0,1}\n/\\n/g' "$TOP_SRCDIR/version/extra_version_description" 2> /dev/null)\""
# The sanitize step uses sed with a script to replace all
# non-alpha-numeric values, except " " (space), to "-".
# The formatting step uses sed with a script to join all lines
- # by replacing "\n" with litteral string c-style "\n".
+ # by replacing "\n" with literal string c-style "\n".
# shellcheck disable=SC2012
echo "#define BT_VERSION_EXTRA_PATCHES \"$(ls -1 "$TOP_SRCDIR/version/extra_patches" | $GREP -v '^README.adoc' | $SED -E ':a ; N ; $!ba ; s/[^a-zA-Z0-9 \n\t\.]/-/g ; s/\r{0,1}\n/\\n/g' 2> /dev/null)\""
} >> common/version.i.tmp
*
* In terms of ownership:
* 1) The graph is the components' parent,
- * 2) The graph is the connnections' parent,
+ * 2) The graph is the connections' parent,
* 3) Components share the ownership of their connections,
* 4) A connection holds weak references to its two component endpoints.
*/
* by its downstream owner.
*
* For the same reason, there is no way that this iterator could
- * have seeked (cannot seek a self message iterator).
+ * have sought (cannot seek a self message iterator).
*/
BT_ASSERT_DBG(iterator->state ==
BT_MESSAGE_ITERATOR_STATE_ACTIVE);
/*
* This function is installed as the iterator's next callback after we have
- * auto-seeked (seeked to the beginning and fast-forwarded) to send the
+ * auto-sought (sought to the beginning and fast-forwarded) to send the
* messages saved in iterator->auto_seek.msgs. Once this is done, the original
* next callback is put back.
*/
}
/*
- * Compare 2 messages to order them in a determinitic way based on their
+ * Compare 2 messages to order them in a deterministic way based on their
* types.
- * Returns -1 is left mesage must go first
- * Returns 1 is right mesage must go first
+ * Returns -1 is left message must go first
+ * Returns 1 is right message must go first
*/
static
int compare_messages_by_type(struct messages_to_compare *msgs)
/*
* Ensure the message iterator's `stored_values` array is large enough to
- * accomodate `storing_index`.
+ * accommodate `storing_index`.
*
* We may need more slots in the array than initially allocated if more
* metadata arrives along the way.
}
goto end;
case STATE_EMIT_MSG_DISCARDED_EVENTS:
- /* create_msg_discared_events() logs errors */
+ /* create_msg_discarded_events() logs errors */
*message = create_msg_discarded_events(msg_it);
if (!*message) {
goto end;
case STATE_EMIT_MSG_DISCARDED_PACKETS:
- /* create_msg_discared_packets() logs errors */
+ /* create_msg_discarded_packets() logs errors */
*message = create_msg_discarded_packets(msg_it);
if (!*message) {
}
/*
- * Unconditionnally write the packet sequence number as, even if
+ * Unconditionally write the packet sequence number as, even if
* there's no possible discarded packets message, it's still
* useful information to have.
*/
* accumulated message objects in the output
* message array, so we need to return
* BT_MESSAGE_ITERATOR_NEXT_METHOD_STATUS_OK so that they are
- * transfered to downstream. This other status occurs
+ * transferred to downstream. This other status occurs
* again the next time muxer_msg_iter_do_next() is
* called, possibly without any accumulated
* message, in which case we'll return it.
if (metadata_fp) {
ret = fclose(metadata_fp);
if (ret) {
- BT_LOGE_ERRNO("Cannot close metatada file stream", ": path=\"%s\"", path);
+ BT_LOGE_ERRNO("Cannot close metadata file stream", ": path=\"%s\"", path);
}
}
* by this component. We CANNOT send it as is.
*
* The only expected scenario in which that could happen is the
- * following, everything else is a bug in this component, relay deamon,
+ * following, everything else is a bug in this component, relay daemon,
* or CTF parser.
*
* Expected scenario: The CTF message iterator emitted discarded
/*
* Get the timestamp in nanoseconds from origin of this
- * messsage.
+ * message.
*/
live_get_msg_ts_ns(lttng_live_msg_iter, msg, lttng_live_msg_iter->last_msg_ts_ns,
&curr_msg_ts_ns);
/*
* Insert the next message to the message batch. This will set
- * stream iterator current messsage to NULL so that next time
+ * stream iterator current message to NULL so that next time
* we fetch the next message of that stream iterator
*/
BT_MESSAGE_MOVE_REF(msgs[*count], youngest_stream_iter->current_msg);
/*
* If we gathered messages, return _OK even if the graph was
* interrupted. This allows for the components downstream to at
- * least get the thoses messages. If the graph was indeed
+ * least get the those messages. If the graph was indeed
* interrupted there should not be another _next() call as the
* application will tear down the graph. This component class
* doesn't support restarting after an interruption.
goto end;
}
- /* The relay sent zero bytes of metdata. */
+ /* The relay sent zero bytes of metadata. */
trace->metadata_stream_state = LTTNG_LIVE_METADATA_STREAM_STATE_NOT_NEEDED;
goto end;
}
trace->clock_class = borrow_any_clock_class(trace->trace_class);
}
- /* The metadata was updated succesfully. */
+ /* The metadata was updated successfully. */
trace->metadata_stream_state = LTTNG_LIVE_METADATA_STREAM_STATE_NOT_NEEDED;
break;
* @param addr The memory address to verify
* @param contains Out parameter, true if addr is contained,
* false if not
- * @returns 0 on succes, -1 on failure
+ * @returns 0 on success, -1 on failure
*/
int bt_dwarf_die_contains_addr(struct bt_dwarf_die *die, uint64_t addr,
bool *contains);
bt_trace_borrow_environment_entry_by_index_const(
in_trace, i, &value_name, &value);
- BT_COMP_LOGD("Copying trace environnement entry: "
+ BT_COMP_LOGD("Copying trace environment entry: "
"index=%" PRId64 ", value-addr=%p, value-name=\"%s\"",
i, value, value_name);
BT_ASSERT(!metadata_maps->output_trace_class);
- /* Create the ouput trace class. */
+ /* Create the output trace class. */
metadata_maps->output_trace_class =
bt_trace_class_create(ir_maps->self_comp);
if (!metadata_maps->output_trace_class) {
#include "trace-ir-metadata-field-class-copy.h"
/*
- * This fonction walks througth the nested structures field class to resolve a
+ * This function walks through the nested structures field class to resolve a
* field path object. A field path is made of indexes inside possibly nested
* structures ultimately leading to a field class.
*/
* accumulated message objects in the output
* message array, so we need to return
* BT_SELF_MESSAGE_ITERATOR_STATUS_OK so that they
- * are transfered to downstream. This other status
+ * are transferred to downstream. This other status
* occurs again the next time muxer_msg_iter_do_next()
* is called, possibly without any accumulated
* message, in which case we'll return it.
#include <babeltrace2/babeltrace.h>
/*
- * `bt_field_*_enumeration` are backed by 64 bits integers so the maximun
+ * `bt_field_*_enumeration` are backed by 64 bits integers so the maximum
* number of bitflags in any enumeration is 64.
*/
#define ENUMERATION_MAX_BITFLAGS_COUNT (sizeof(uint64_t) * 8)
*
* This function will set the count to the count of mapping labels that match
* the value. If count == 0, the caller has nothing to do, if count > 0,
- * the label_array contains the labels to print and the caller is reponsible
+ * the label_array contains the labels to print and the caller is responsible
* to call g_free on it once the values have been used.
*/
static
*
* This function will set the count to the count of mapping labels that match
* the value. If count == 0, the caller has nothing to do, if count > 0,
- * the label_array contains the labels to print and the caller is reponsible
+ * the label_array contains the labels to print and the caller is responsible
* to call g_free on it once the values have been used.
*/
static
/*
* g_regex_match allocates `*match_info` even if it returns
* FALSE. If there's no match, we have no use for it, so free
- * it immediatly and don't return it to the caller.
+ * it immediately and don't return it to the caller.
*/
g_match_info_free(*match_info);
*match_info = NULL;
/*
* Initialize Python now.
*
- * This is not done in the library contructor because the
+ * This is not done in the library constructor because the
* interpreter is somewhat slow to initialize. If you don't
* have any potential Python plugins, you don't need to endure
* this waiting time everytime you load the library.
self.assertTrue(flt_iter_initialized)
# Test that creating a message iterator from a sink component on a
- # non-connected inport port raises.
+ # non-connected input port raises.
def test_create_from_sink_component_unconnected_port_raises(self):
class MySink(bt2._UserSinkComponent):
def __init__(comp_self, config, params, obj):
graph.run()
self.assertTrue(seen)
- # Test that creating a message iterator from a message iteartor on a
- # non-connected inport port raises.
+ # Test that creating a message iterator from a message iterator on a
+ # non-connected input port raises.
def test_create_from_message_iterator_unconnected_port_raises(self):
class MyFilterIter(bt2._UserMessageIterator):
def __init__(iter_self, config, port):
return print_encodings(src, shift, len);
}
- /* Run tap-formated tests */
+ /* Run tap-formatted tests */
run_test();
return exit_status();
}
bt_ctf_object_put_ref(ret_field_type);
event = bt_ctf_event_create(event_class);
- ok(event, "Instanciate a complex event");
+ ok(event, "Instantiate a complex event");
ret_event_class = bt_ctf_event_get_class(event);
ok(ret_event_class == event_class,
bt_ctf_object_put_ref(returned_type);
int_16 = bt_ctf_field_create(int_16_type);
- ok(int_16, "Instanciate a signed 16-bit integer");
+ ok(int_16, "Instantiate a signed 16-bit integer");
uint_12 = bt_ctf_field_create(uint_12_type);
- ok(uint_12, "Instanciate an unsigned 12-bit integer");
+ ok(uint_12, "Instantiate an unsigned 12-bit integer");
returned_type = bt_ctf_field_get_type(int_16);
ok(returned_type == int_16_type,
"bt_ctf_field_get_type returns the correct type");
- /* Can't modify types after instanciating them */
+ /* Can't modify types after instantiating them */
ok(bt_ctf_field_type_integer_set_base(uint_12_type,
BT_CTF_INTEGER_BASE_DECIMAL),
- "Check an integer type' base can't be modified after instanciation");
+ "Check an integer type' base can't be modified after instantiation");
ok(bt_ctf_field_type_integer_set_signed(uint_12_type, 0),
- "Check an integer type's signedness can't be modified after instanciation");
+ "Check an integer type's signedness can't be modified after instantiation");
/* Check overflows are properly tested for */
ok(bt_ctf_field_integer_signed_set_value(int_16, -32768) == 0,
"Check 0 is allowed for an unsigned 12-bit integer");
string = bt_ctf_field_create(string_type);
- ok(string, "Instanciate a string field");
+ ok(string, "Instantiate a string field");
ok(bt_ctf_field_string_set_value(string, "A value") == 0,
"Set a string's value");
}
static
-void test_instanciate_event_before_stream(struct bt_ctf_writer *writer,
+void test_instantiate_event_before_stream(struct bt_ctf_writer *writer,
struct bt_ctf_clock *clock)
{
int ret = 0;
"bt_ctf_event_get_stream returns an event's stream after it has been appended");
end:
ok(ret == 0,
- "Create an event before instanciating its associated stream");
+ "Create an event before instantiating its associated stream");
bt_ctf_object_put_ref(stream);
bt_ctf_object_put_ref(ret_stream);
bt_ctf_object_put_ref(stream_class);
== 0, "Add version (%s) environment field to writer instance",
name.version);
ok(bt_ctf_writer_add_environment_field(writer, "machine", name.machine)
- == 0, "Add machine (%s) environment field to writer istance",
+ == 0, "Add machine (%s) environment field to writer instance",
name.machine);
/* Define a clock and add it to the trace */
ok(!bt_ctf_clock_create("signed"),
"Illegal clock name rejected");
clock = bt_ctf_clock_create(clock_name);
- ok(clock, "Clock created sucessfully");
+ ok(clock, "Clock created successfully");
returned_clock_name = bt_ctf_clock_get_name(clock);
ok(returned_clock_name, "bt_ctf_clock_get_name returns a clock name");
ok(returned_clock_name ? strcmp(returned_clock_name, clock_name) == 0 : 0,
ok(bt_ctf_trace_get_stream_count(trace) == 0,
"bt_ctf_trace_get_stream_count() succeeds and returns the correct value (0)");
stream1 = bt_ctf_writer_create_stream(writer, stream_class);
- ok(stream1, "Instanciate a stream class from writer");
+ ok(stream1, "Instantiate a stream class from writer");
ok(bt_ctf_trace_get_stream_count(trace) == 1,
"bt_ctf_trace_get_stream_count() succeeds and returns the correct value (1)");
stream = bt_ctf_trace_get_stream_by_index(trace, 0);
ret = bt_ctf_field_type_structure_add_field(packet_header_type,
packet_header_field_type, "should_fail");
ok(ret < 0,
- "Trace packet header type can't be modified once a stream has been instanciated");
+ "Trace packet header type can't be modified once a stream has been instantiated");
/*
* Try to modify the packet context type after a stream has been
ret = bt_ctf_field_type_structure_add_field(packet_context_type,
packet_context_field_type, "should_fail");
ok(ret < 0,
- "Packet context type can't be modified once a stream has been instanciated");
+ "Packet context type can't be modified once a stream has been instantiated");
/*
* Try to modify the stream event context type after a stream has been
ret = bt_ctf_field_type_structure_add_field(stream_event_context_type,
integer_type, "should_fail");
ok(ret < 0,
- "Stream event context type can't be modified once a stream has been instanciated");
+ "Stream event context type can't be modified once a stream has been instantiated");
- /* Should fail after instanciating a stream (frozen) */
+ /* Should fail after instantiating a stream (frozen) */
ok(bt_ctf_stream_class_set_clock(stream_class, clock),
"Changes to a stream class that was already instantiated fail");
test_clock_utils();
- test_instanciate_event_before_stream(writer, clock);
+ test_instantiate_event_before_stream(writer, clock);
append_simple_event(stream_class, stream1, clock);
5. Copy the resulting trace back into the Babeltrace repository.
When running babeltrace with the `--debug-info-target-prefix` option or
-`target-prefix` component paramater set to the directory containing the right
+`target-prefix` component parameter set to the directory containing the right
`libhello-so` file. In the example used above, the `libhello-so` file is in the
`x86-64-linux-gnu/dwarf-full/` directory.
In the printed trace, the `my_provider:my_first_tracepoint` events should
stream = trace.create_stream(sc, 0)
# Use event class name length as timestamp so that both stream
- # beginning message are not at the same time. This test is targetting
+ # beginning message are not at the same time. This test is targeting
# event message.
sb_msg = msg_iter._create_stream_beginning_message(stream, len(ec.name))
ev_msg = msg_iter._create_event_message(ec, stream, 50)
stream = trace.create_stream(sc, 0)
# Use event class id as timestamp so that both stream beginning message
- # are not at the same time. This test is targetting event message.
+ # are not at the same time. This test is targeting event message.
sb_msg = msg_iter._create_stream_beginning_message(stream, ec.id)
ev_msg = msg_iter._create_event_message(ec, stream, 50)
se_msg = msg_iter._create_stream_end_message(stream, iter_id * 193)
int main(void)
{
- /* Run tap-formated tests */
+ /* Run tap-formatted tests */
run_test();
return exit_status();
/**
* The objective of this test is to implement and expand upon the scenario
* described in the reference counting documentation and ensure that any node of
- * the Trace, Stream Class, Event Class, Stream and Event hiearchy keeps all
+ * the Trace, Stream Class, Event Class, Stream and Event hierarchy keeps all
* other "alive" and reachable.
*
* External tools (e.g. valgrind) should be used to confirm that this
test_stored_values() {
# Split metadata, where the new metadata requires additional stored
# value slots in CTF message iterators.
- local test_text="split metadata requiring additionnal stored values"
+ local test_text="split metadata requiring additional stored values"
local cli_args_template="-i lttng-live net://localhost:@PORT@/host/hostname/stored-values -c sink.text.details"
local server_args=("$test_data_dir/stored-values.json")
local expected_stdout="${test_data_dir}/stored-values.expect"
mut_exclu_group.add_argument(
"-t",
"--test-case",
- help="Run a specfic test module name, test class "
+ help="Run a specific test module name, test class "
"name, or test method name "
"(e.g. test_event.EventTestCase.test_clock_value)",
type=str,
sub("^(not )?ok[ \t]*", "", line)
# If the result has an explicit number, get it and strip it; otherwise,
- # automatically assing the next progresive number to it.
+ # automatically assign the next progressive number to it.
if (line ~ /^[0-9]+$/ || line ~ /^[0-9]+[^a-zA-Z0-9_]/)
{
match(line, "^[0-9]+")
#endif
/* '## __VA_ARGS__' is a gcc'ism. C99 doesn't allow the token pasting
- and requires the caller to add the final comma if they've ommitted
+ and requires the caller to add the final comma if they've omitted
the optional arguments */
#ifdef __GNUC__
# define ok(e, test, ...) ((e) ? \
projects / babeltrace.git / commitdiff
