---
layout: default
title: alkan lab / support
categories:
- support
---
Development and application of novel genome assembly algorithms
that use multiple data sources
Birden Fazla Veri Kaynağı Kullanabilen Yeni Genom Birleştirme
Algoritmalarının Tasarımı Ve Uygulanması
- Scientific and Technical Research Council of Turkey
(TÜBİTAK-1001-112E135), 2012-2015
- PI: Can Alkan
- Students: Elif Dal, Fatma Kahveci, Shatlyk Ashyralyyev
- Total 313,152 TL for three years
(approx. €134,000).
- The goal of this project is to develop assembly algorithms to
more reliably construct de novo
genome assemblies using data from multiple sources.
Abstract
The application of high throughput sequencing (HTS) technologies are
revolutionizing the field of genomics, providing unprecedented
resolution to study genomes of different species, and normal and disease
causing human genetic variation. Although significant advances have been
made to analyze HTS data, there are still several hurdles in fully
utilizing the power of HTS.
Although we can now generate data at a rate previously unimaginable, the
analysis of the data is proceeding at a slower pace because: 1)
unprecedented amounts of data introduce challenges in computational
infrastructure in terms of both storage and processing power; 2) reads
are often associated with high sequence errors and shorter read length;
and 3) currently available algorithms to analyze HTS data and the HTS
data themselves show different biases against different regions of the
genome. Due to these problems, the information available in the
sequencing datasets is not completely mined. There is a need to forge an
alliance between computer science and genomics to devise better methods
to use the massive amount of sequence data to unleash the full power of
HTS methodologies.
Thanks to the substantially reduced cost of genome sequencing, there is
now great interest in sequencing the genomes of thousands of species to
better understand the genomic diversity across different organisms,
organismal biology and genome evolution. In the last few years many
genomes are sequenced: plants such as rice, grape, wheat, potato, corn,
cucumber; and animals such as the giant panda, turkey, gorilla,
orangutan, bonobo, opossum, elephant, etc. Recently more ambitious
projects like the Genome 10K Consortium are started to sequence the
genomes of 10.000 vertebrate species. However, the aforementioned
limitations of the HTS technologies also affected de novo sequencing
studies that aim to construct the reference genomes of various species.
This is mainly due to the repetitive structure of the genomes of most
species, the short sequence reads generated by current platforms, and
the increased error rate. Thus there are still problems to solve to
increase the accuracy of the assembled genomes; otherwise any biological
conclusions derived from non-accurate genome assemblies would be
incorrect.
Reasoning from the previous observations and empirical evidence that all
current HTS platforms show different strengths and biases, we propose to
devise novel genome assembly algorithms that use data from multiple
sources, including, when available, data derived from laboratory
experiments to better assemble the genomes of new species. We will test
our algorithms with 1) a set of bacterial artificial chromosomes (BACs)
generated from a hydatidiform mole resource that were sequenced using
both the Illumina and Pacific Biosciences platforms, and test the
assembly accuracy by comparing with high quality assemblies of the same
resource using capillary sequence data; 2) whole genome shotgun sequence
libraries generated from a haploid genome (hydatidiform mole) and
sequenced using 454/Roche and Illumina platforms, several BAC end
sequences from the same library sequenced using capillary sequencing,
and physical fingerprinting data. The basepair calling accuracy of the
Illumina platform coupled with longer matepairs from the 454/Roche, long
sequences from Pacific Biosciences, long “jumps” from BAC end
sequencing, and the physical ordering of the BACs from the fingerprint
data will be used in harmony to improve the genome assembly. In long
term, we will also incorporate methodologies that utilize data from
upcoming nanotechnology-based sequencing platforms such as the Oxford
Nanopore Technologies. Enhanced algorithms that can better assemble
genomes will improve our understanding of the biology of genomes.
Dissemination
- Early postzygotic mutations
contribute to de novo variation in a healthy monozygotic twin
pair. Gülşah M Dal, Bekir Ergüner, Mahmut S
Sağıroğlu, Bayram Yüksel, Onur Emre Onat, Can
Alkan, Tayfun Özçelik. J Med Genet,
51(7):455-459, 2014
- Whole
genome sequencing of Turkish genomes reveals functional private
alleles and impact of genetic interactions with Europe, Asia and
Africa. Can Alkan,
Pınar Kavak, Mehmet Somel, Omer Gokcumen, Serkan Uğurlu, Ceren
Saygı, Elif Dal,
Kuyaş Buğra, Tunga Güngör, S Cenk Sahinalp, Nesrin Özören and
Cemalettin Bekpen. BMC Genomics, 15(1):963, 2014.
- A hypergraph-based model for hybrid de novo assembly. Shatlyk
Askyralyyev, Can Firtina, Cevdet Aykanat, Can
Alkan. Bertinoro Computational Biology Meeting, June
14-18, Bertinoro, Italy, 2015.
- Evaluation
of genome scaffolding tools using pooled clone sequencing. Elif Dal and Can Alkan. Turkish J
of Biology, 42, 471-476, 2018.


Here shows the functions of RF PHY.
◆ getBLE_ChipId()
| uint8_t getBLE_ChipId |
( |
void |
| ) |
|
Get BLE Device Chip ID
This function is used to get BLE Device Chip ID.
- Returns
- Chip ID
◆ getBLE_TxFIFOAddr()
| uint32_t getBLE_TxFIFOAddr |
( |
void |
| ) |
|
Get TX FIFI Address
This function is used to get TX FIFO RAM start address.
- Returns
- TX FIFO address.
◆ getRF_Mode()
| BleRF_Mode getRF_Mode |
( |
void |
| ) |
|
Get Current BLE Device RF Mode
This function is used to get current RF mode.
- Return values
-
| BLERFMODE_ACTIVE | : The BLE device RF is in active mode. |
| BLERFMODE_SLEEP | : The BLE device RF is in sleep mode. |
◆ setBLE_KernelStateHandle()
| BleStackStatus setBLE_KernelStateHandle |
( |
void |
| ) |
|
Enable BLE Kernel. Must do it after setRF_SpiIoMapping and setRF_Init.
- Note
- If no any BLE Stack (LL&Host) task is running then run user application task.
The task priority is LL>Host>User_app.
- Return values
-
| BLESTACK_STATUS_FREE | : Stack (LL&Host task) is not running, can run user application task. |
| BLESTACK_STATUS_ERR_BUSY | : Stack (LL&Host task) is running, can NOT run user application task. |
◆ setMCU_WakeupRetentionTime()
| BleStackStatus setMCU_WakeupRetentionTime |
( |
uint8_t |
retentionTime | ) |
|
Set MCU Wake-up Retention Time
This parameter adjusts the retention time required for the MCU to wake up from sleep mode, plus some necessary parameters set via SPI operation.
The unit of the MCU wake-up retention time is 125us.
- Attention
- This command MUST be called before setRF_Init.
- Note
- The default MCU Wake-up Retention Time is set to 1 (125us = 1*125us).
-
MCU wake-up retention time range is from MCU_WAKEUP_RETENSIONTIME_MIN to MCU_WAKEUP_RETENSIONTIME_MAX.
- Parameters
-
| [in] | retentionTime | : MCU wake-up retention time in 125us. |
- Return values
-
| BLESTACK_STATUS_ERR_INVALID_STATE | : MCU Wake-up Retention Time can NOT be modified while running BLE stack. |
| BLESTACK_STATUS_ERR_INVALID_PARAM | : Invalid parameter. |
| BLESTACK_STATUS_SUCCESS | : Setting completed. |
◆ setRF_EnableXtalClkOutput()
| BleStackStatus setRF_EnableXtalClkOutput |
( |
void |
| ) |
|
Set Crystal Clock Output
This function is used to enable crystal 16MHz Clock output.
- Attention
- This command MUST be called before setRF_Init.
-
RF sleep mode will be disabled automatically when user enable crystal clock (16MHz) output.
- Return values
-
| BLESTACK_STATUS_ERR_INVALID_STATE | : Crystal clock output can NOT be enabled while running BLE stack. |
| BLESTACK_STATUS_SUCCESS | : Setting completed. |
◆ setRF_EnterDeepSleep()
| BleStackStatus setRF_EnterDeepSleep |
( |
void |
| ) |
|
Set RF Enter Deep Sleep Mode
- Attention
- RF can NOT enter Deep Sleep Mode if enabled crystal clock output.
-
It will not wake up until call setRF_WakeUpFromDeepSleep.
- Return values
-
| BLESTACK_STATUS_ERR_INVALID_STATE | : RF phy or BLE stack has not initialized. |
| BLESTACK_STATUS_ERR_NOT_SUPPORTED | : This command is not supported if crystal clock output enabled. |
| BLESTACK_STATUS_SUCCESS | : Setting completed. |
◆ setRF_Init()
| BleStackStatus setRF_Init |
( |
PowerRegulator_Mode |
powerMode, |
|
|
uint8_t |
xtalFeq |
|
) |
| |
Initializes the BLE RF Phy.
- Attention
- Must initial BLE RF Phy after setRF_SpiIoMapping.
- Parameters
-
- Return values
-
| BLESTACK_STATUS_ERR_INVALID_PARAM | : invalid parameter. |
| BLESTACK_STATUS_SUCCESS | : RF initialization is successful. |
◆ setRF_RssiValueOffset()
| void setRF_RssiValueOffset |
( |
uint8_t |
offset | ) |
|
Set BLE RSSI Offset Value to adjust RSSI Value
- Note
- The default BLE RSSI Offset Value is +26dBm.
- Parameters
-
| [in] | offset | : rssi offset value. |
- Returns
- none
◆ setRF_WakeUpFromDeepSleep()
| BleStackStatus setRF_WakeUpFromDeepSleep |
( |
void |
| ) |
|
Set RF External Wakeup From Deep Sleep Mode
- Attention
- This command is not supported if enabled crystal clock output.
- Note
- After external wakeup from deep sleep mode, the BLE stack will do setRF_Init and setBLE_BleStackInit again.
Then BLE is in standby mode.
- Return values
-
| BLESTACK_STATUS_ERR_INVALID_STATE | : RF phy or BLE stack has not initialized or not in deep sleep mode. |
| BLESTACK_STATUS_ERR_NOT_SUPPORTED | : This command is not supported if crystal clock output enabled. |
| BLESTACK_STATUS_SUCCESS | : Setting completed. |


- Autotest::Rspec discovery
- should add the rspec autotest plugin
- Autotest::Rspec rspec_commands
- should contain the various commands, ordered by preference
- Autotest::Rspec selection of rspec command
- should try to find the spec command if it exists in ./bin and use it above everything else
- should otherwise select the default spec command in gem_dir/bin/spec
- should raise an error if no spec command is found at all
- Autotest::Rspec selection of rspec command (windows compatibility issues)
- should use the ALT_SEPARATOR if it is non-nil (PENDING: autotest got re-worked so this is failing for the moment)
- should not use the ALT_SEPATOR if it is nil
- Autotest::Rspec adding spec.opts --options
- should return the command line option to add spec.opts if the options file exists
- should return an empty string if no spec.opts exists
- Autotest::Rspec
- should make the apropriate test command
- Autotest::Rspec test mappings
- should map all filenames in spec/ which end in .rb
- should map all names in lib which end in .rb to the corresponding ones in spec/
- should find all files in spec/shares/* and the spec helper in spec/spec_helper
- Autotest::Rspec handling results
- should call hook(:red) if there are failures
- should call hook(:green) if there are no failures
- Autotest::Rspec handling failed results
- should scan the output into a multi-dimensional array,
consisting of the failing spec's name as the first element,
and the failure as the second
- Autotest::Rspec specs for a given file
- should find the spec file for a given lib file
- should find the spec file if given a spec file
- should only find the file if the file is being tracked (in @file)
- Autotest::Rspec consolidating failures
- should return no failures if no failures were given in the output
- should return a hash with the spec filename => spec name for each failure or error
- Spec::Example::Configuration#mock_with
- should default mock framework to rspec
- should let you set rspec mocking explicitly
- should let you set mocha
- should let you set flexmock
- should let you set rr
- should let you set an arbitrary adapter module
- Spec::Example::Configuration#include
- should include the submitted module in ExampleGroup subclasses
- should let you define modules to be included for a specific type
- should not include modules in a type they are not intended for
- Spec::Example::Configuration#prepend_before
- Special Example Group
- calls prepend_before
- prepends the before block on all instances of the passed in type
- Spec::Example::Configuration#append_before
- Special Example Group
- calls append_before
- calls append_before on the type
- Spec::Example::Configuration#prepend_after
- Special Example Group
- calls prepend_after
- prepends the after block on all instances of the passed in type
- Spec::Example::Configuration#append_after
- Special Example Group
- calls append_after
- calls append_after on the type
- Spec::Example::ExampleGroupSubclass
- should run
- should have access to instance variables
- should have access to class variables
- should have access to constants
- should have access to methods defined in the Example Group
- Spec::Example::ExampleGroupSubclass
- should run
- Spec::Example::ExampleGroupFactory with :foobar registered as custom type
- should #get the default ExampleGroup type when passed nil
- should #get the default ExampleGroup for unregistered non-nil values
- should #get custom type for :foobar
- should #get the actual type when that is passed in
- Spec::Example::ExampleGroupFactory#create_example_group
- should create a uniquely named class
- should create a Spec::Example::Example subclass by default
- should create a Spec::Example::Example when :type => :default
- should create a Spec::Example::Example when :type => :default
- should create specified type when :type => :something_other_than_default
- should create a type indicated by :spec_path
- should create a type indicated by :spec_path (with spec_path generated by caller on windows)
- should create and register a Spec::Example::Example if :shared => true
- should favor the :type over the :spec_path
- should register ExampleGroup by default
- should enable unregistering of ExampleGroups
- ExampleGroupMethods#describe
- should create a subclass of the ExampleGroup when passed a block
- should not inherit examples
- ExampleGroupMethods#it
- should should create an example instance
- ExampleGroupMethods#xit
- should NOT should create an example instance
- should warn that it is disabled
- ExampleGroupMethods#examples
- should have Examples
- should not include methods that begin with test (only when TU interop is loaded)
- should include methods that begin with should and has an arity of 0 in suite
- should not include methods that begin with test_ and has an arity > 0 in suite
- should not include methods that begin with should_ and has an arity > 0 in suite
- should run should_methods
- ExampleGroupMethods#set_description#set_description(String)
- .description should return the String passed into .set_description
- .described_type should provide nil as its type
- ExampleGroupMethods#set_description#set_description(Type)
- .description should return a String representation of that type (fully qualified) as its name
- .described_type should return the passed in type
- ExampleGroupMethods#set_description#set_description(String, Type)
- .description should return String then space then Type
- .described_type should return the passed in type
- ExampleGroupMethods#set_description#set_description(Type, String not starting with a space)
- .description should return the Type then space then String
- ExampleGroupMethods#set_description#set_description(Type, String starting with .)
- .description should return the Type then String
- ExampleGroupMethods#set_description#set_description(Type, String containing .)
- .description should return the Type then space then String
- ExampleGroupMethods#set_description#set_description(Type, String starting with .)
- should return the Type then String
- ExampleGroupMethods#set_description#set_description(Type, String containing .)
- .description should return the Type then space then String
- ExampleGroupMethods#set_description#set_description(String, Type, String)
- .description should return the first String then space then Type then second String
- ExampleGroupMethods#set_description#set_description(Hash representing options)
- .spec_path should expand the passed in :spec_path option passed into the constructor
- .description_options should return all the options passed in
- ExampleGroupMethods#description
- should return the same description instance for each call
- should not add a space when description_text begins with #
- should not add a space when description_text begins with .
- should return the class name if nil
- should return the class name if nil
- ExampleGroupMethods#description_parts
- should return an Array of the current class description args
- should return an Array of the description args from each class in the hierarchy
- ExampleGroupMethods#described_type
- should return passed in type
- should return #described_type of superclass when no passed in type
- ExampleGroupMethods#remove_after
- should unregister a given after(:each) block
- ExampleGroupMethods#include
- should have accessible class methods from included module
- ExampleGroupMethods#number_of_examples
- should count number of specs
- ExampleGroupMethods#class_eval
- should allow constants to be defined
- ExampleGroupMethods#register
- should add ExampleGroup to set of ExampleGroups to be run
- ExampleGroupMethods#unregister
- should remove ExampleGroup from set of ExampleGroups to be run
- Spec::Example::ExampleGroup via a class definition
- should understand module scoping
- should allow class variables to be defined
- Spec::Example::ExampleGroup via a class definition without a class variable
- should not retain class variables from other Example classes
- Spec::Example::ExampleGroup#pending
- should raise a Pending error when its block fails
- should raise Spec::Example::PendingExampleFixedError when its block does not fail
- Spec::Example::ExampleGroup#run
- should not run when there are no examples
- Spec::Example::ExampleGroup#run when before_each fails
- should not run example block
- should run after_each
- should report failure location when in before_each
- Spec::Example::ExampleGroup#run Spec::Example::ExampleGroup#run on dry run
- should not run before(:all) or after(:all)
- should not run example
- Spec::Example::ExampleGroup#run Spec::Example::ExampleGroup#run with specified examples when specified_examples matches entire ExampleGroup
- should not run the Examples in the ExampleGroup
- Spec::Example::ExampleGroup#run Spec::Example::ExampleGroup#run with specified examples Spec::Example::ExampleGroup#run when specified_examples matches only Example description
- should not run the example
- Spec::Example::ExampleGroup#run Spec::Example::ExampleGroup#run with specified examples Spec::Example::ExampleGroup#run when specified_examples does not match an Example description
- should not run the example
- Spec::Example::ExampleGroup#run Spec::Example::ExampleGroup#run with specified examples Spec::Example::ExampleGroup#run when specified_examples matches an Example description
- should run only the example, when there in only one
- should run only the one example
- Spec::Example::ExampleGroup#run Spec::Example::ExampleGroup#run with success
- should send reporter add_example_group
- should run example on run
- should run before(:all) block only once
- should run after(:all) block only once
- after(:all) should have access to all instance variables defined in before(:all)
- should copy instance variables from before(:all)'s execution context into spec's execution context
- should not add global before callbacks for untargetted example_group
- should add global before callbacks for targetted example_groups
- should order before callbacks from global to local
- should order after callbacks from local to global
- should have accessible instance methods from included module
- should include targetted modules included using configuration
- should include any predicate_matchers included using configuration
- should use a mock framework set up in config
- Spec::Example::ExampleGroup#run Spec::Example::ExampleGroup#run with pending example that has a failing assertion
- should send example_pending to formatter
- Spec::Example::ExampleGroup#run Spec::Example::ExampleGroup#run with pending example that does not have a failing assertion
- should add an example failure to the TestResult
- should send example_pending to formatter
- Spec::Example::ExampleGroup#run Spec::Example::ExampleGroup#run when before(:all) fails
- should add an example failure to the TestResult
- should not run any example
- should run ExampleGroup after(:all)
- should run example_group after(:all)
- should supply before(:all) as description
- Spec::Example::ExampleGroup#run Spec::Example::ExampleGroup#run when before(:each) fails
- should add an example failure to the TestResult
- should run after(:all)
- Spec::Example::ExampleGroup#run Spec::Example::ExampleGroup#run when any example fails
- should add an example failure to the TestResult
- should run after(:all)
- Spec::Example::ExampleGroup#run Spec::Example::ExampleGroup#run when first after(:each) block fails
- should add an example failure to the TestResult
- should run second after(:each) block
- Spec::Example::ExampleGroup#run Spec::Example::ExampleGroup#run when first before(:each) block fails
- should add an example failure to the TestResult
- should not run second before(:each)
- Spec::Example::ExampleGroup#run Spec::Example::ExampleGroup#run when failure in after(:all)
- should add an example failure to the TestResult
- should return false
- Spec::Example::ExampleGroup subclasses
- should have access to the described_type
- should concat descriptions when nested
- Enumerable
- should be included in examples because it is a module
- An Enumerable as a second argument
- should be included in examples because it is a module
- Enumerable as the parent of nested example groups
- should be included in examples because it is a module (PENDING: need to make sure nested groups know the described type)
- String
- should not be included in examples because it is not a module
- Spec::Example::ExampleMatcher#matches?
- should match correct example_group and example
- should not match wrong example
- should not match wrong example_group
- should match example only
- should match example_group only
- should match example_group ending with before(:all)
- should escape regexp chars
- should match when example_group is modularized
- Spec::Example::ExampleMatcher#matches? normal case
- matches when passed in example matches
- does not match when no passed in examples match
- Spec::Example::ExampleMatcher#matches? where description has '::' in it
- matches when passed in example matches
- does not match when no passed in examples match
- ExampleMethods with an included module that is reopened
- should have repoened methods
- Spec::Example::ExampleMethods lifecycle
- #<Class:0x11c6ff0>
- should use ExampleMethods callbacks
- should pass before and after callbacks to all ExampleGroup subclasses
- Spec::Example::ExampleMethods lifecycle run_with_description_capturing
- should provide the generated description
- should clear the global generated_description
- Nested Example Groups
- should run before(:all), before(:each), example, after(:each), after(:all) in order
- Nested Example Groups nested example group
- should run all before and after callbacks
- Spec::Example::Pending
- should raise an ExamplePendingError if no block is supplied
- should raise an ExamplePendingError if a supplied block fails as expected
- should raise a PendingExampleFixedError if a supplied block starts working
- predicate_matcher[method_on_object] = matcher_method
- should match matcher_method if method_on_object returns true
- should not match matcher_method if method_on_object returns false
- Spec::Example::ExampleGroup with :shared => true
- should accept an optional options hash
- should return all shared example_groups
- should register as shared example_group
- should not be shared when not configured as shared
- should complain when adding a second shared example_group with the same description
- should NOT complain when adding the same shared example_group instance again
- should NOT complain when adding the same shared example_group again (i.e. file gets reloaded)
- should NOT complain when adding the same shared example_group in same file with different absolute path
- should complain when adding a different shared example_group with the same name in a different file with the same basename
- should add examples to current example_group using it_should_behave_like
- should add examples to current example_group using include
- should add examples to current example_group using it_should_behave_like with a module
- should run shared examples
- should run setup and teardown from shared example_group
- should run before(:all) and after(:all) only once from shared example_group
- should include modules, included into shared example_group, into current example_group
- should make methods defined in the shared example_group available in consuming example_group
- should raise when named shared example_group can not be found
- Grandparent ExampleGroup Parent ExampleGroup
- should bar
- Grandparent ExampleGroup Parent ExampleGroup Child ExampleGroup
- should bam
- Diff
- should output unified diff of two strings
- should output unified diff message of two arrays
- should output unified diff message of two objects
- Diff in context format
- should output unified diff message of two objects
- Object#should
- should accept and interact with a matcher
- should ask for a failure_message when matches? returns false
- should raise error if it receives false directly
- should raise error if it receives false (evaluated)
- should raise error if it receives true
- should raise error if it receives nil
- should raise error if it receives no argument and it is not used as a left side of an operator (PENDING: Is it even possible to catch this?)
- Object#should_not
- should accept and interact with a matcher
- should ask for a negative_failure_message when matches? returns true
- should raise error if it receives false directly
- should raise error if it receives false (evaluated)
- should raise error if it receives true
- should raise error if it receives nil
- should raise error if it receives no argument and it is not used as a left side of an operator (PENDING: Is it even possible to catch this?)
- Spec::Expectations#fail_with with no diff
- should handle just a message
- should handle an Array
- Spec::Expectations#fail_with with diff
- should not call differ if no expected/actual
- should call differ if expected/actual are presented separately
- should call differ if expected/actual are not strings
- should not call differ if expected or actual are procs
- should call differ if expected/actual are presented in an Array with message
- Spec::Extensions::Main
- should create an Options object
- should respond to #describe
- should respond to #context
- should raise when no block given to describe
- should raise when no description given to describe
- should registered ExampleGroups by default
- should not run unregistered ExampleGroups
- should create a shared ExampleGroup with share_examples_for
- Spec::Extensions::Main#share_as
- should create a shared ExampleGroup
- should create a constant that points to a Module
- should bark if you pass it something not-constantizable
- ExampleGroup with test/unit/interop with passing examples
- should output 0 failures
- should return an exit code of 0
- ExampleGroup with test/unit/interop with failing examples
- should output 1 failure
- should return an exit code of 256
- ExampleGroup with test/unit/interop with example that raises an error
- should output 1 failure
- should return an exit code of 256
- Test::Unit::TestCase with passing test case
- should output 0 failures
- should return an exit code of 0
- Test::Unit::TestCase with failing test case
- should output 1 failure
- should return an exit code of 256
- Test::Unit::TestCase with test case that raises an error
- should output 1 failure
- should return an exit code of 256
- TestSuiteAdapter
- should pass
- Spec::Matchers::BeClose
- should match when value == target
- should match when value < (target + delta)
- should match when value > (target - delta)
- should not match when value == (target - delta)
- should not match when value < (target - delta)
- should not match when value == (target + delta)
- should not match when value > (target + delta)
- should provide a useful failure message
- should describe itself
- should be_predicate
- should pass when actual returns true for :predicate?
- should pass when actual returns true for :predicates? (present tense)
- should fail when actual returns false for :predicate?
- should fail when actual does not respond to :predicate?
- should_not be_predicate
- should pass when actual returns false for :sym?
- should fail when actual returns true for :sym?
- should fail when actual does not respond to :sym?
- should be_predicate(*args)
- should pass when actual returns true for :predicate?(*args)
- should fail when actual returns false for :predicate?(*args)
- should fail when actual does not respond to :predicate?
- should_not be_predicate(*args)
- should pass when actual returns false for :predicate?(*args)
- should fail when actual returns true for :predicate?(*args)
- should fail when actual does not respond to :predicate?
- should be_true
- should pass when actual equal(true)
- should fail when actual equal(false)
- should be_false
- should pass when actual equal(false)
- should fail when actual equal(true)
- should be_nil
- should pass when actual is nil
- should fail when actual is not nil
- should_not be_nil
- should pass when actual is not nil
- should fail when actual is nil
- should be <
- should pass when < operator returns true
- should fail when < operator returns false
- should be <=
- should pass when <= operator returns true
- should fail when <= operator returns false
- should be >=
- should pass when >= operator returns true
- should fail when >= operator returns false
- should be >
- should pass when > operator returns true
- should fail when > operator returns false
- should be ==
- should pass when == operator returns true
- should fail when == operator returns false
- should be ===
- should pass when === operator returns true
- should fail when === operator returns false
- should be
- should pass if actual is true or a set value
- should fail if actual is false
- should fail if actual is nil
- should be(value)
- should pass if actual.equal?(value)
- should fail if !actual.equal?(value)
- should change(actual, message)
- should pass when actual is modified by the block
- should fail when actual is not modified by the block
- should_not change(actual, message)
- should pass when actual is not modified by the block
- should fail when actual is not modified by the block
- should change { block }
- should pass when actual is modified by the block
- should fail when actual is not modified by the block
- should warn if passed a block using do/end
- should_not change { block }
- should pass when actual is modified by the block
- should fail when actual is not modified by the block
- should warn if passed a block using do/end
- should change(actual, message).by(expected)
- should pass when attribute is changed by expected amount
- should fail when the attribute is changed by unexpected amount
- should fail when the attribute is changed by unexpected amount in the opposite direction
- should change{ block }.by(expected)
- should pass when attribute is changed by expected amount
- should fail when the attribute is changed by unexpected amount
- should fail when the attribute is changed by unexpected amount in the opposite direction
- should change(actual, message).by_at_least(expected)
- should pass when attribute is changed by greater than the expected amount
- should pass when attribute is changed by the expected amount
- should fail when the attribute is changed by less than the expected amount
- should change{ block }.by_at_least(expected)
- should pass when attribute is changed by greater than expected amount
- should pass when attribute is changed by the expected amount
- should fail when the attribute is changed by less than the unexpected amount
- should change(actual, message).by_at_most(expected)
- should pass when attribute is changed by less than the expected amount
- should pass when attribute is changed by the expected amount
- should fail when the attribute is changed by greater than the expected amount
- should change{ block }.by_at_most(expected)
- should pass when attribute is changed by less than expected amount
- should pass when attribute is changed by the expected amount
- should fail when the attribute is changed by greater than the unexpected amount
- should change(actual, message).from(old)
- should pass when attribute is == to expected value before executing block
- should fail when attribute is not == to expected value before executing block
- should change{ block }.from(old)
- should pass when attribute is == to expected value before executing block
- should fail when attribute is not == to expected value before executing block
- should change(actual, message).to(new)
- should pass when attribute is == to expected value after executing block
- should fail when attribute is not == to expected value after executing block
- should change{ block }.to(new)
- should pass when attribute is == to expected value after executing block
- should fail when attribute is not == to expected value after executing block
- should change(actual, message).from(old).to(new)
- should pass when #to comes before #from
- should pass when #from comes before #to
- should change{ block }.from(old).to(new)
- should pass when #to comes before #from
- should pass when #from comes before #to
- Matchers should be able to generate their own descriptions
- should == expected
- should not == expected
- should be empty (arbitrary predicate)
- should not be empty (arbitrary predicate)
- should be true
- should be false
- should be nil
- should be > n
- should be predicate arg1, arg2 and arg3
- should be_few_words predicate should be transformed to 'be few words'
- should preserve a proper prefix for be predicate
- should equal
- should_not equal
- should eql
- should not eql
- should have_key
- should have n items
- should have at least n items
- should have at most n items
- should include
- should match
- should raise_error
- should raise_error with type
- should raise_error with type and message
- should respond_to
- should throw symbol
- should throw symbol (with named symbol)
- Spec::Matchers::Eql
- should match when actual.eql?(expected)
- should not match when !actual.eql?(expected)
- should describe itself
- should provide message, expected and actual on #failure_message
- should provide message, expected and actual on #negative_failure_message
- Spec::Matchers::Equal
- should match when actual.equal?(expected)
- should not match when !actual.equal?(expected)
- should describe itself
- should provide message, expected and actual on #failure_message
- should provide message, expected and actual on #negative_failure_message
- should exist, within an example group
- should pass if target exists
- should fail if target does not exist
- should pass if target doesn't exist
- should exist, outside of an example group
- should pass if target exists
- Spec::Expectations::ExpectationMatcherHandler.handle_matcher
- should ask the matcher if it matches
- should explain when the matcher parameter is not a matcher
- Spec::Expectations::NegativeExpectationMatcherHandler.handle_matcher
- should explain when matcher does not support should_not
- should ask the matcher if it matches
- should explain when the matcher parameter is not a matcher
- Spec::Expectations::ExpectationMatcherHandler
- should handle submitted args
- should handle the submitted block
- should explain when matcher does not support should_not
- should have_sym(*args)
- should pass if #has_sym?(*args) returns true
- should fail if #has_sym?(*args) returns false
- should fail if target does not respond to #has_sym?
- should_not have_sym(*args)
- should pass if #has_sym?(*args) returns false
- should fail if #has_sym?(*args) returns true
- should fail if target does not respond to #has_sym?
- should have(n).items
- should pass if target has a collection of items with n members
- should convert :no to 0
- should fail if target has a collection of items with < n members
- should fail if target has a collection of items with > n members
- should have(1).item when Inflector is defined
- should pluralize the collection name
- should have(n).items where result responds to items but returns something other than a collection
- should provide a meaningful error
- should_not have(n).items
- should pass if target has a collection of items with < n members
- should pass if target has a collection of items with > n members
- should fail if target has a collection of items with n members
- should have_exactly(n).items
- should pass if target has a collection of items with n members
- should convert :no to 0
- should fail if target has a collection of items with < n members
- should fail if target has a collection of items with > n members
- should have_at_least(n).items
- should pass if target has a collection of items with n members
- should pass if target has a collection of items with > n members
- should fail if target has a collection of items with < n members
- should provide educational negative failure messages
- should have_at_most(n).items
- should pass if target has a collection of items with n members
- should fail if target has a collection of items with > n members
- should pass if target has a collection of items with < n members
- should provide educational negative failure messages
- have(n).items(args, block)
- should pass args to target
- should pass block to target
- have(n).items where target IS a collection
- should reference the number of items IN the collection
- should fail when the number of items IN the collection is not as expected
- have(n).characters where target IS a String
- should pass if the length is correct
- should fail if the length is incorrect
- have(n).things on an object which is not a collection nor contains one
- should fail
- should include(expected)
- should pass if target includes expected
- should fail if target does not include expected
- should include(with, multiple, args)
- should pass if target includes all items
- should fail if target does not include any one of the items
- should_not include(expected)
- should pass if target does not include expected
- should fail if target includes expected
- should match(expected)
- should pass when target (String) matches expected (Regexp)
- should fail when target (String) does not match expected (Regexp)
- should provide message, expected and actual on failure
- should_not match(expected)
- should pass when target (String) matches does not match (Regexp)
- should fail when target (String) matches expected (Regexp)
- should provide message, expected and actual on failure
- The Spec::Matchers module gets included in the execution context of every spec.
This module should provide the following methods, each of which returns a Matcher object.
- be_true
- be_false
- be_nil
- be_arbitrary_predicate
- be_close
- change
- eql
- equal
- have
- have_exactly
- have_at_least
- have_at_most
- include
- match
- raise_error
- satisfy
- throw_symbol
- respond_to
- Spec::Matchers#method_missing
- should convert be_xyz to Be(:be_xyz)
- should convert have_xyz to Has(:have_xyz)
- The anything() mock argument constraint matcher
- should == #<Object:0x1838988>
- should == Class
- should == 1
- should == "a string"
- should == :a_symbol
- The boolean() mock argument constraint matcher
- should == true
- should == false
- should not == #<Object:0x182e834>
- should not == Class
- should not == 1
- should not == "a string"
- should not == :a_symbol
- The an_instance_of() mock argument constraint matcher
- should == "string"
- should ==
- should delegate message to target
- should fail when target.==(actual) returns false
- should_not ==
- should delegate message to target
- should fail when target.==(actual) returns false
- should ===
- should delegate message to target
- should fail when target.===(actual) returns false
- should_not ===
- should delegate message to target
- should fail when target.===(actual) returns false
- should =~
- should delegate message to target
- should fail when target.=~(actual) returns false
- should_not =~
- should delegate message to target
- should fail when target.=~(actual) returns false
- should >
- should pass if > passes
- should fail if > fails
- should >=
- should pass if >= passes
- should fail if > fails
- should <
- should pass if < passes
- should fail if > fails
- should <=
- should pass if <= passes
- should fail if > fails
- should raise_error
- should pass if anything is raised
- should fail if nothing is raised
- should_not raise_error
- should pass if nothing is raised
- should fail if anything is raised
- should raise_error(message)
- should pass if RuntimeError is raised with the right message
- should pass if any other error is raised with the right message
- should fail if RuntimeError error is raised with the wrong message
- should fail if any other error is raised with the wrong message
- should_not raise_error(message)
- should pass if RuntimeError error is raised with the different message
- should pass if any other error is raised with the wrong message
- should fail if RuntimeError is raised with message
- should fail if any other error is raised with message
- should raise_error(NamedError)
- should pass if named error is raised
- should fail if nothing is raised
- should fail if another error is raised
- should_not raise_error(NamedError)
- should pass if nothing is raised
- should pass if another error is raised
- should fail if named error is raised
- should raise_error(NamedError, error_message) with String
- should pass if named error is raised with same message
- should fail if nothing is raised
- should fail if incorrect error is raised
- should fail if correct error is raised with incorrect message
- should_not raise_error(NamedError, error_message) with String
- should pass if nothing is raised
- should pass if a different error is raised
- should pass if same error is raised with different message
- should fail if named error is raised with same message
- should raise_error(NamedError, error_message) with Regexp
- should pass if named error is raised with matching message
- should fail if nothing is raised
- should fail if incorrect error is raised
- should fail if correct error is raised with incorrect message
- should_not raise_error(NamedError, error_message) with Regexp
- should pass if nothing is raised
- should pass if a different error is raised
- should pass if same error is raised with non-matching message
- should fail if named error is raised with matching message
- should respond_to(:sym)
- should pass if target responds to :sym
- should fail target does not respond to :sym
- should respond_to(message1, message2)
- should pass if target responds to both messages
- should fail target does not respond to first message
- should fail target does not respond to second message
- should fail target does not respond to either message
- should_not respond_to(:sym)
- should pass if target does not respond to :sym
- should fail target responds to :sym
- should satisfy { block }
- should pass if block returns true
- should fail if block returns false
- should_not satisfy { block }
- should pass if block returns false
- should fail if block returns true
- Spec::Matchers::SimpleMatcher
- should match pass match arg to block
- should provide a stock failure message
- should provide a stock negative failure message
- should provide a description
- Spec::Matchers::ThrowSymbol (constructed with no Symbol)
- should match if any Symbol is thrown
- should not match if no Symbol is thrown
- should provide a failure message
- should provide a negative failure message
- Spec::Matchers::ThrowSymbol (constructed with a Symbol)
- should match if correct Symbol is thrown
- should not match if no Symbol is thrown
- should not match if correct Symbol is thrown
- should provide a failure message when no Symbol is thrown
- should provide a failure message when wrong Symbol is thrown
- should provide a negative failure message
- should only match NameErrors raised by uncaught throws
- AnyNumberOfTimes
- should pass if any number of times method is called many times
- should pass if any number of times method is called once
- should pass if any number of times method is not called
- Spec::Mocks::ArgumentExpectation
- should consider an object that responds to #matches? and #description to be a matcher
- should NOT consider an object that only responds to #matches? to be a matcher
- at_least
- should fail if method is never called
- should fail when called less than n times
- should fail when at least once method is never called
- should fail when at least twice method is called once
- should fail when at least twice method is never called
- should pass when at least n times method is called exactly n times
- should pass when at least n times method is called n plus 1 times
- should pass when at least once method is called once
- should pass when at least once method is called twice
- should pass when at least twice method is called three times
- should pass when at least twice method is called twice
- at_most
- should fail when at most n times method is called n plus 1 times
- should fail when at most once method is called twice
- should fail when at most twice method is called three times
- should pass when at most n times method is called exactly n times
- should pass when at most n times method is called less than n times
- should pass when at most n times method is never called
- should pass when at most once method is called once
- should pass when at most once method is never called
- should pass when at most twice method is called once
- should pass when at most twice method is called twice
- should pass when at most twice method is never called
- An RSpec Mock
- should hide internals in its inspect representation
- should_receive
- should work when object lies about responding to a method
- should work when class lies about responding to a method
- should cleanup after itself
- mock failure
- should tell you when it receives the right message with the wrong args
- should tell you when it receives the right message with the wrong args if you stub the method (PENDING: fix bug 15719)
- A Partial Mock
- should respect subclasses
- should
- Stubs should correctly restore module methods
- 1 - stub the open method
- 2 - use File.open to create example.txt
- An object where respond_to? is true and does not have method
- should not raise an exception for Object
- should not raise an exception for mock
- Bug report 8302:
- class method is not restored correctly when proxied
- instance method is not restored correctly when proxied
- failing MockArgumentConstraints
- should reject non boolean
- should reject non numeric
- should reject non string
- should reject goose when expecting a duck
- should fail if regexp does not match submitted string
- should fail if regexp does not match submitted regexp
- should fail for a hash w/ wrong values
- should fail for a hash w/ wrong keys
- should match against a Matcher
- should fail no_args with one arg
- failing deprecated MockArgumentConstraints
- should reject non boolean
- should reject non numeric
- should reject non string
- Mock ordering
- should pass two calls in order
- should pass three calls in order
- should fail if second call comes first
- should fail if third call comes first
- should fail if third call comes second
- should ignore order of non ordered calls
- Spec::Mocks::Space
- should verify all mocks within
- should reset all mocks within
- should clear internal mocks on reset_all
- should only add an instance once
- Spec::Mocks::Mock
- should report line number of expectation of unreceived message
- should pass when not receiving message specified as not to be received
- should pass when receiving message specified as not to be received with different args
- should fail when receiving message specified as not to be received
- should fail when receiving message specified as not to be received with args
- should pass when receiving message specified as not to be received with wrong args
- should allow block to calculate return values
- should allow parameter as return value
- should return nil if no return value set
- should raise exception if args dont match when method called
- should fail if unexpected method called
- should use block for expectation if provided
- should fail if expectation block fails
- should fail right away when method defined as never is received (PENDING: Used to pass (false positive). Which one is wrong, the spec or the actual behavior?)
- should eventually fail when method defined as never is received
- should raise when told to
- should raise passed an Exception instance
- should raise RuntimeError with passed message
- should not raise when told to if args dont match
- should throw when told to
- should raise when explicit return and block constrained
- should ignore args on any args
- should fail on no args if any args received
- should fail when args are expected but none are received
- should yield 0 args to blocks that take a variable number of arguments
- should yield 0 args multiple times to blocks that take a variable number of arguments
- should yield one arg to blocks that take a variable number of arguments
- should yield one arg 3 times consecutively to blocks that take a variable number of arguments
- should yield many args to blocks that take a variable number of arguments
- should yield many args 3 times consecutively to blocks that take a variable number of arguments
- should yield single value
- should yield single value 3 times consecutively
- should yield two values
- should yield two values 3 times consecutively
- should fail when calling yielding method with wrong arity
- should fail when calling yielding method consecutively with wrong arity
- should fail when calling yielding method without block
- should be able to mock send
- should be able to raise from method calling yielding mock
- should clear expectations after verify
- should restore objects to their original state on rspec_reset
- should work even after method_missing starts raising NameErrors instead of NoMethodErrors
- should temporarily replace a method stub on a mock
- should temporarily replace a method stub on a non-mock
- should assign stub return values
- a mock message receiving a block
- should call the block after #should_receive
- should call the block after #once
- should call the block after #twice
- should call the block after #times
- should call the block after #any_number_of_times
- should call the block after #with
- should call the block after #ordered
- a Mock expectation with multiple return values and no specified count
- should return values in order to consecutive calls
- should complain when there are too few calls
- should complain when there are too many calls
- a Mock expectation with multiple return values with a specified count equal to the number of values
- should return values in order to consecutive calls
- should complain when there are too few calls
- should complain when there are too many calls
- a Mock expectation with multiple return values specifying at_least less than the number of values
- should use last return value for subsequent calls
- should fail when called less than the specified number
- a Mock expectation with multiple return values with a specified count larger than the number of values
- should use last return value for subsequent calls
- should fail when called less than the specified number
- should fail when called greater than the specified number
- a mock acting as a NullObject
- should allow explicit expectation
- should fail verification when explicit exception not met
- should ignore unexpected methods
- should expected message with different args first
- should expected message with different args second
- OnceCounts
- once should fail when called once with wrong args
- once should fail when called twice
- once should fail when not called
- once should pass when called once
- once should pass when called once with specified args
- once should pass when called once with unspecified args
- calling :should_receive with an options hash
- should report the file and line submitted with :expected_from
- should use the message supplied with :message
- using a Partial Mock,
- should name the class in the failure message
- should not conflict with @options in the object
- should_not_receive should mock out the method
- should_not_receive should return a negative message expectation
- should_receive should mock out the method
- should_receive should handle a hash
- should_receive should handle an inner hash
- should_receive should return a message expectation
- should_receive should verify method was called
- should_receive should also take a String argument
- should_not_receive should also take a String argument
- should use report nil in the error message
- Partially mocking an object that defines ==, after another mock has been defined
- should not raise an error when stubbing the object
- PartialMockUsingMocksDirectly
- should fail when expected message is not received
- should fail when message is received with incorrect args
- should pass when expected message is received
- should pass when message is received with correct args
- should revert to original method if existed
- Spec::Mocks::Methods handling argument constraints with DEPRECATED symbols
- should accept true as boolean
- should accept false as boolean
- should accept fixnum as numeric
- should accept float as numeric
- should accept string as anything
- should match string
- should match no args against any_args
- should match no args against no_args
- Spec::Mocks::Methods handling argument constraints
- should accept true as boolean()
- should accept false as boolean()
- should accept fixnum as an_instance_of(Numeric)
- should accept float as an_instance_of(Numeric)
- should accept string as anything()
- should match duck type with one method
- should match duck type with two methods
- should match no args against any_args()
- should match one arg against any_args()
- should match no args against no_args()
- Spec::Mocks::Methods handling non-constraint arguments
- should match non special symbol (can be removed when deprecated symbols are removed)
- should match string against regexp
- should match regexp against regexp
- should match against a hash submitted and received by value
- should match against a hash submitted by reference and received by value
- should match against a hash submitted by value and received by reference
- should match against a Matcher
- PreciseCounts
- should fail when exactly n times method is called less than n times
- should fail when exactly n times method is never called
- should pass if exactly n times method is called exactly n times
- should pass multiple calls with different args and counts
- should pass mutiple calls with different args
- a mock
- should answer false for received_message? when no messages received
- should answer true for received_message? when message received
- should answer true for received_message? when message received with correct args
- should answer false for received_message? when message received with incorrect args
- A method stub
- should return expected value when expected message is received
- should ignore when expected message is received
- should ignore when message is received with args
- should ignore when expected message is not received
- should clear itself when verified
- should return values in order to consecutive calls
- should keep returning last value in consecutive calls
- should revert to original instance method if there is one
- should revert to original class method if there is one
- should yield a specified object
- should yield multiple times with multiple calls to and_yield
- should yield a specified object and return another specified object
- should throw when told to
- should override a pre-existing stub
- should limit
- A method stub with args
- should not complain if not called
- should not complain if called with arg
- should complain if called with no arg
- should complain if called with other arg
- should not complain if also mocked w/ different args
- should complain if also mocked w/ different args AND called w/ a 3rd set of args
- should support options
- TwiceCounts
- twice should fail when call count is higher than expected
- twice should fail when call count is lower than expected
- twice should fail when called twice with wrong args on the first call
- twice should fail when called twice with wrong args on the second call
- twice should pass when called twice
- twice should pass when called twice with specified args
- twice should pass when called twice with unspecified args
- The bin/spec script
- should have no warnings
- Spec::Runner::ClassAndArgumentsParser.parse
- should use a single : to separate class names from arguments
- should raise an error when passed an empty string
- Spec::Runner::CommandLine.run
- should run directory
- should run file
- should raise when file does not exist
- should return true when in --generate-options mode
- should dump even if Interrupt exception is occurred
- should heckle when options have heckle_runner
- should run examples backwards if options.reverse is true
- should pass its ExampleGroup to the reporter
- runs only selected Examples when options.examples is set
- sets Spec.run to true
- Spec::Runner::DrbCommandLine without running local server
- should print error when there is no running local server
- Spec::Runner::DrbCommandLine with local server
- should run against local server
- should output green colorized text when running with --colour option
- should output red colorized text when running with -c option
- ExecutionContext
- should provide duck_type()
- should violate when violated()
- should provide mock()
- should provide stub()
- should add method stubs to stub()
- Spec::Runner::Formatter::FailingExampleGroupsFormatter
- should add example name for each failure
- should delimit ExampleGroup superclass descriptions with :
- should remove druby url, which is used by Spec::Distributed
- Spec::Runner::Formatter::FailingExamplesFormatter
- should add example name for each failure
- Spec::Runner::Formatter::HtmlFormatter
- should produce HTML identical to the one we designed manually with --diff
- should produce HTML identical to the one we designed manually with --dry-run
- Spec::Runner::Formatter::ProfileFormatter
- should print a heading
- should record the current time when starting a new example
- should correctly record a passed example
- should sort the results in descending order
- should print the top 10 results
- Spec::Runner::Formatter::ProgressBarFormatter
- should produce line break on start dump
- should produce standard summary without pending when pending has a 0 count
- should produce standard summary
- should push green dot for passing spec
- should push red F for failure spec
- should push magenta F for error spec
- should push blue F for fixed pending spec
- should push nothing on start
- should ensure two ':' in the first backtrace
- should dump pending
- ProgressBarFormatter outputting to custom out
- should not throw NoMethodError on output_to_tty?
- Spec::Runner::Formatter::ProgressBarFormatter dry run
- should not produce summary on dry run
- Spec::Runner::Formatter::SnippetExtractor
- should fall back on a default message when it doesn't understand a line
- should fall back on a default message when it doesn't find the file
- Spec::Runner::Formatter::TextMateFormatter functional spec using --diff
- should produce HTML identical to the one we designed manually with --diff
- Spec::Runner::Formatter::TextMateFormatter functional spec using --dry-run
- should produce HTML identical to the one we designed manually with --dry-run
- Spec::Runner::Formatter::SpecdocFormatter where ExampleGroup has no superclasss with a description
- should produce standard summary without pending when pending has a 0 count
- should produce standard summary
- should push ExampleGroup name
- when having an error, should push failing spec name and failure number
- when having an expectation failure, should push failing spec name and failure number
- should push nothing on start
- should push nothing on start dump
- should push passing spec name
- should push pending example name and message
- should dump pending
- Spec::Runner::Formatter::SpecdocFormatter where ExampleGroup has two superclasses with a description
- when having an error, should push failing spec name and failure number
- when having an expectation failure, should push failing spec name and failure number
- Spec::Runner::Formatter::Story::HtmlFormatter
- should just be poked at
- should create spans for params
- should create spanes for params in regexp steps
- should create a ul for collected_steps
- Spec::Runner::Formatter::Story::PlainTextFormatter
- should summarize the number of scenarios when the run ends
- should summarize the number of successful scenarios when the run ends
- should summarize the number of failed scenarios when the run ends
- should end cleanly (no characters on the last line) with successes
- should end cleanly (no characters on the last line) with failures
- should end cleanly (no characters on the last line) with pending steps
- should summarize the number of pending scenarios when the run ends
- should only count the first failure in one scenario
- should only count the first pending in one scenario
- should only count a failure before the first pending in one scenario
- should produce details of the first failure each failed scenario when the run ends
- should produce details of each pending step when the run ends
- should document a story title and narrative
- should document a scenario name
- should document a step by sentence-casing its name
- should document additional givens using And
- should document additional events using And
- should document additional outcomes using And
- should document a GivenScenario followed by a Given using And
- should document steps with replaced params
- should document regexp steps with replaced params
- should append PENDING for the first pending step
- should append PENDING for pending after already pending
- should append FAILED for the first failiure
- should append SKIPPED for the second failiure
- should append SKIPPED for the a failiure after PENDING
- should print some white space after each story
- should print nothing for collected_steps
- should ignore messages it doesn't care about
- HeckleRunner
- should heckle all methods in all classes in a module
- should heckle all methods in a class
- should fail heckling when the class is not found
- should heckle specific method in a class (with #)
- should heckle specific method in a class (with .)
- Heckler
- should say yes to tests_pass? if specs pass
- should say no to tests_pass? if specs fail
- Heckler
- should run examples on tests_pass?
- NoisyBacktraceTweaker
- should leave anything in lib spec dir
- should leave anything in spec dir
- should leave bin spec
- should not barf on nil backtrace
- should clean up double slashes
- OptionParser
- should accept files to include
- should accept dry run option
- should eval and use custom formatter when none of the builtins
- should support formatters with relative and absolute paths, even on windows
- should not be verbose by default
- should not use colour by default
- should print help to stdout if no args (PENDING: A regression since 1.0.8)
- should print help to stdout
- should print instructions about how to require missing formatter
- should print version to stdout
- should require file when require specified
- should support c option
- should support queens colour option
- should support us color option
- should support single example with -e option
- should support single example with -s option (will be removed when autotest supports -e)
- should support single example with --example option
- should read several example names from file if --example is given an existing file name
- should read no examples if given an empty file
- should use html formatter when format is h
- should use html story formatter when format is h
- should use html formatter when format is html
- should use html story formatter when format is html
- should use html formatter with explicit output when format is html:test.html
- should use noisy backtrace tweaker with b option
- should use noisy backtrace tweaker with backtrace option
- should use quiet backtrace tweaker by default
- should use progress bar formatter by default
- should use specdoc formatter when format is s
- should use specdoc formatter when format is specdoc
- should support diff option when format is not specified
- should use unified diff format option when format is unified
- should use context diff format option when format is context
- should use custom diff format option when format is a custom format
- should print instructions about how to fix missing differ
- should support --line to identify spec
- should fail with error message if file is dir along with --line
- should fail with error message if file does not exist along with --line
- should fail with error message if more than one files are specified along with --line
- should fail with error message if --example and --line are used simultaneously
- should heckle when --heckle is specified (and platform is not windows)
- should read options from file when --options is specified
- should default the formatter to ProgressBarFormatter when using options file
- should read spaced and multi-line options from file when --options is specified
- should save config to file when --generate-options is specified
- should save config to file when -G is specified
- when --drb is specified, calls DrbCommandLine all of the other ARGV arguments
- should reverse spec order when --reverse is specified
- should set an mtime comparator when --loadby mtime
- should use the standard runner by default
- should use a custom runner when given
- should use a custom runner with extra options
- Spec::Runner::Options#examples
- should default to empty array
- Spec::Runner::Options#include_pattern
- should default to '**/*.rb'
- Spec::Runner::Options#files_to_load
- should load files following pattern
- should not load files not following pattern
- should load files in directories not following pattern
- should not load files in directories not following pattern
- Spec::Runner::Options#backtrace_tweaker
- should default to QuietBacktraceTweaker
- Spec::Runner::Options#dry_run
- should default to false
- Spec::Runner::Options#context_lines
- should default to 3
- Spec::Runner::Options#parse_diff with nil
- should make diff_format unified
- should set Spec::Expectations.differ to be a default differ
- Spec::Runner::Options#parse_diff with 'unified'
- should make diff_format unified and uses default differ_class
- should set Spec::Expectations.differ to be a default differ
- Spec::Runner::Options#parse_diff with 'context'
- should make diff_format context and uses default differ_class
- should set Spec::Expectations.differ to be a default differ
- Spec::Runner::Options#parse_diff with Custom::Differ
- should use custom differ_class
- should set Spec::Expectations.differ to be a default differ
- Spec::Runner::Options#parse_diff with missing class name
- should raise error
- Spec::Runner::Options#parse_example
- with argument thats not a file path, sets argument as the example
- with argument that is a file path, sets examples to contents of the file
- Spec::Runner::Options#examples_should_not_be_run
- should cause #run_examples to return true and do nothing
- Spec::Runner::Options#load_class
- should raise error when not class name
- Spec::Runner::Options#reporter
- returns a Reporter
- Spec::Runner::Options#add_example_group affecting passed in example_group
- Some Examples
- runs 1
- runs 2
- runs all examples when options.examples is nil
- Some Examples
- runs 1
- runs 2
- keeps all example_definitions when options.examples is empty
- Spec::Runner::Options#add_example_group affecting example_group
- adds example_group when example_group has example_definitions and is not shared
- Spec::Runner::Options#remove_example_group
- should remove the ExampleGroup from the list of ExampleGroups
- Spec::Runner::Options#run_examples
- should use the standard runner by default
- should use a custom runner when given
- should use a custom runner with extra options
- Spec::Runner::Options#run_examples when there are examples
- runs the Examples and outputs the result
- sets #examples_run? to true
- Spec::Runner::Options#run_examples when there are no examples
- does not run Examples and does not output a result
- sets #examples_run? to false
- Spec::Runner::CommandLine
- should not output twice
- QuietBacktraceTweaker
- should not barf on nil backtrace
- should remove anything from textmate ruby bundle
- should remove anything in lib spec dir
- should remove mock_frameworks/rspec
- should remove bin spec
- should clean up double slashes
- Spec::Runner::Reporter
- should assign itself as the reporter to options
- should tell formatter when example_group is added
- should handle multiple example_groups with same name
- should handle multiple examples with the same name
- should push stats to formatter even with no data
- should push time to formatter
- Spec::Runner::Reporter Spec::Runner::Reporter reporting one passing example
- should tell formatter example passed
- should not delegate to backtrace tweaker
- should account for passing example in stats
- Spec::Runner::Reporter Spec::Runner::Reporter reporting one failing example
- should tell formatter that example failed
- should delegate to backtrace tweaker
- should account for failing example in stats
- Spec::Runner::Reporter Spec::Runner::Reporter reporting one pending example (ExamplePendingError)
- should tell formatter example is pending
- should account for pending example in stats
- Spec::Runner::Reporter Spec::Runner::Reporter reporting one pending example (PendingExampleFixedError)
- should tell formatter pending example is fixed
- SpecParserSubject described
- 6
- SpecParserSubject described
- 7
- SpecParser
- should find spec name for 'specify' at same line
- should find spec name for 'specify' at end of spec line
- should find context for 'context' above all specs
- should find spec name for 'it' at same line
- should find spec name for 'it' at end of spec line
- should find context for 'describe' above all specs
- should find nearest example name between examples
- should find nothing outside a context
- should find context name for type
- should find context and spec name for type
- should find context and description for type
- should find context and description and example for type
- should find context and description for type with modifications
- should find context and described and example for type with modifications
- should find example group
- should find example
- Spec::Runner.configure
- should yield global configuration
- Spec::Story::Extensions::Main#run_story
- should create a PlainTextStoryRunner with run_story
- should yield the runner if arity == 1
- should run in the runner if arity == 0
- should tell the PlainTextStoryRunner to run with run_story
- Spec::Story::Extensions::Main#steps_for
- should have no steps for a non existent key
- should create steps for a key
- should append steps to steps_for a given key
- Spec::Story::Extensions::Main#with_steps_for adding new steps
- should result in a group containing pre-existing steps and newly defined steps
- should not add its steps to the existing group
- Spec::Story::Extensions::Main#with_steps_for running a story
- should create a PlainTextStoryRunner with a path
- should create a PlainTextStoryRunner with a path and options
- should pass the group it creates to the runner's steps
- should run a story
- Kernel#Story
- should delegate to ::Spec::Story::Runner.story_runner
- Spec::Story::GivenScenario
- should execute a scenario from the current story in its world
- Spec::Story::Runner::PlainTextStoryRunner
- should provide access to steps
- should parse a story file
- should build up a mediator with its own steps and the singleton story_runner
- should build up a parser with the mediator
- should tell the mediator to run the stories
- should accept a block instead of a path
- should tell you if you try to run with no path set
- should pass options to the mediator
- should provide access to its options
- Spec::Story::Runner::ScenarioCollector
- should construct scenarios with the supplied story
- Spec::Story::Runner::ScenarioRunner
- should run a scenario in its story
- should allow scenarios to share methods
- should notify listeners when a scenario starts
- should notify listeners when a scenario succeeds
- should notify listeners ONCE when a scenario raises an error
- should notify listeners when a scenario is pending
- Spec::Story::Runner::StoryMediator
- should have no stories
- should create two stories
- should create a scenario
- should create a given scenario step if one matches (PENDING: need to untangle the dark mysteries of the story runner - something needs to get stubbed here)
- should create a given step if one matches
- should create a pending step if no given step matches
- should create a when step if one matches
- should create a pending step if no when step matches
- should create a then step if one matches
- should create a pending step if no 'then' step matches
- should pass options to the stories it creates
- Spec::Story::Runner::StoryParser
- should parse no lines
- should ignore text before the first Story: begins
- should create a story
- should create a story when line has leading spaces
- should add a one line narrative to the story
- should add a multi line narrative to the story
- should exclude blank lines from the narrative
- should exclude Scenario from the narrative
- Spec::Story::Runner::StoryParser in Story state
- should create a second Story for Story
- should include And in the narrative
- should create a Scenario for Scenario
- should include Given in the narrative
- should include Given: in the narrative
- should include When in the narrative
- should include Then in the narrative
- should include other in the story
- Spec::Story::Runner::StoryParser in Scenario state
- should create a Story for Story
- should create a Scenario for Scenario
- should raise for And
- should create a Given for Given
- should create a Given for Given:
- should create a GivenScenario for GivenScenario
- should create a GivenScenario for GivenScenario:
- should transition to Given state after GivenScenario
- should transition to Given state after GivenScenario:
- should create a When for When
- should create a When for When:
- should create a Then for Then
- should create a Then for Then:
- should ignore other
- Spec::Story::Runner::StoryParser in Given state
- should create a Story for Story
- should create a Scenario for Scenario
- should create a second Given for Given
- should create a second Given for And
- should create a second Given for And:
- should create a When for When
- should create a When for When:
- should create a Then for Then
- should create a Then for Then:
- should ignore other
- Spec::Story::Runner::StoryParser in When state
- should create a Story for Story
- should create a Scenario for Scenario
- should create Given for Given
- should create Given for Given:
- should create a second When for When
- should create a second When for When:
- should create a second When for And
- should create a second When for And:
- should create a Then for Then
- should create a Then for Then:
- should ignore other
- Spec::Story::Runner::StoryParser in Then state
- should create a Story for Story
- should create a Scenario for Scenario
- should create Given for Given
- should create Given for Given:
- should create When for When
- should create When for When:
- should create a Then for Then
- should create a Then for Then:
- should create a second Then for And
- should create a second Then for And:
- should ignore other
- Spec::Story::Runner::StoryRunner
- should collect all the stories
- should gather all the scenarios in the stories
- should run each scenario in a separate object
- should use the provided world creator to create worlds
- should notify listeners of the scenario count when the run starts
- should notify listeners when a story starts
- should notify listeners when the run ends
- should run a story in an instance of a specified class
- should pass initialization params through to the constructed instance
- should find a scenario in the current story by name
- should clean the steps between stories
- Spec::Story::Runner module
- should wire up a singleton StoryRunner
- should set its options based on ARGV
- should add a reporter to the runner classes
- should add a documenter to the runner classes if one is specified
- should add any registered listener to the runner classes
- Spec::Story::Scenario
- should not raise an error if no body is supplied
- Spec::Story::StepGroup
- should not find a matcher if empty
- should create a given_scenario matcher
- should create a given matcher
- should create a when matcher
- should create a them matcher
- should add a matcher object
- should add it matchers to another StepGroup (with one given)
- should add it matchers to another StepGroup (with some of each type)
- should append another collection
- should append several other collections
- should yield itself on initialization
- should support defaults
- should create a Given
- should create a When
- should create a Then
- should create steps in a block
- should clear itself
- should tell you when it is empty
- should tell you when it is not empty
- should handle << nil
- Spec::Story::StepMother
- should store a step by name and type
- should NOT raise an error if a step is missing
- should create a default step which raises a pending error
- should clear itself
- should use assigned steps
- Spec::Story::Step matching
- should match a text string
- should not match a text string that does not start the same
- should not match a text string that does not end the same
- should match a text string with a param
- should not be greedy
- should match a text string with 3 params
- should match a text string with a param at the beginning
- should match a text string with a param at the end
- should not match a different string
- should match a regexp
- should match a regexp with a match group
- should match a regexp with a named variable
- should not match a non matching regexp
- should not match a non matching regexp with a named variable
- should not get bogged down by parens in strings
- should match any option of an alteration
- should match alteration as well as a variable
- should match alteration as well as a named variable
- should match alteration as well as a anonymous and named variable
- Spec::Story::Step
- should make complain with no block
- should perform itself on an object
- should perform itself with one parameter with match expression
- should perform itself with one parameter without a match expression
- should perform itself with 2 parameters
- should perform itself when defined with a regexp with 2 parameters
- Spec::Story::Story
- should run itself in a given object
- should not raise an error if no block is supplied
- should raise when error raised running in another object
- should use the steps it is told to using a StepGroup
- should use the steps it is told to using a key
- should use the steps it is told to using multiple keys
- Spec::Story::World
- should create an object that mixes in a World
- should create a World from any object type
- should pass arguments to #new when creating an object of a specified type that mixes in a world
- should execute a Given, When or Then step
- should interpret Given... And... as multiple givens
- should interpret When... And... as multiple events
- should interpret Then... And... as multiple outcomes
- should reuse a given across scenarios
- should reuse an event across scenarios
- should reuse an outcome across scenarios
- should preserve instance variables between steps within a scenario
- should invoke a reused step in the new object instance
- should collect a failure from a Given step
- should collect a failure from a When step
- should collect a failure from a Then step
- should inform listeners when it runs a Given, When or Then step
- should tell listeners but not execute the step in dry-run mode
- should suppress listeners while it runs a GivenScenario
- should interpret GivenScenario... And... as multiple givens
- should provide rspec matchers
- should use assigned matchers
- Translator
- should translate files
- should translate context_setup do
- should translate context_setup {foo}
- should translate context ' to describe '
- should translate context " to describe "
- should translate spaces then context " to describe "
- should not translate context=foo
- should not translate context = foo
- should not translate context = foo
- should translate should_be_close
- should translate should_not_raise
- should translate should_throw
- should not translate 0.9 should_not
- should leave should_not_receive
- should leave should_receive
- should translate multi word predicates
- should translate multi word predicates prefixed with be
- should translate be(expected) to equal(expected)
- should translate instance_of
- should translate should_be <
- should translate should_be <=
- should translate should_be >=
- should translate should_be >
- should translate should_be_happy
- should translate custom method taking regexp with parenthesis
- should translate custom method taking regexp without parenthesis
- should translate should_not_be_nil
- should translate kind of
- should translate should_be_true
- should translate should_match on a regexp, in a var, in a block
- should translate close_to without parens
- should support symbol arguments
- should support instance var arguments
- should support lambdas as expecteds
- should support fully qualified names
- should translate redirects
- should translate :any_args
- should translate :anything
- should translate :boolean
- should translate :no_args
- should translate :numeric
- should translate :string
- Special Example Group
- calls prepend_before
- Special Example Group
- calls append_before
- Special Example Group
- calls prepend_after
- Special Example Group
- calls append_after
- #<Class:0x11c6ff0>
- should use ExampleMethods callbacks
- Some Examples
- runs 1
- runs 2
- Some Examples
- runs 1
- runs 2
- Some Examples
- uses this example_group


 More majors and minors will be available soon. As we are still developing this application, you may experience unexpected errors. Please kindly contact us if you discovered any errors.
Close


Global Name Service Research Group
Projects
Robust wireless stack
Seeks to develop a robust protcol stack for diverse wireless networks ranging from well-connected mesh networks to to highly mobile, vehicular, or disruption-tolerant networks.
- Routing: R3 (MobiCom'11) ensures robust routing performance in any kind of a multi-hop wireless network. R3 builds upon our work on RAPID (IEEE/ACM ToN'10, Sigcomm'07), one of the first DTN routing protocols validated by real deployment.
- Transport: Hop (NSDI'09) is a "block-switched" hop-by-hop transport protocol that dramatically outperforms TCP and is robust to routing disruptions.
Content Networking
Our recent paper (Infocom'11) reveals surprising implications of replicated content on ISP traffic engineering.


Best Preschool 2018
Phasellus accumsan, justo ac mollis pharetra, ex dui pharetra nisl, a scelerisque ipsum nulla ac sem. Integer hendrerit egestas magna, eu pellentesque velit placerat
Classes for your child
Why Choose Us
Donec at cursus sem. Duis condimentum posuere purus, at venenatis tellus mollis. Vestibulum cursus convallis venenatis.Positive learning environment
Great facilities at Wonderland
Well-designed activies for kids
Award for best preschool course 2018
Professional teachers
Pricing Plans
$15
Morning
8.00 AM - 12.30 PM
- 2 meals /day
- Medical Support
- Indoor Activities
- Outdoor Activities
$20
Afternoon
8.00 AM - 12.30 PM
- 2 meals /day
- Medical Support
- Indoor Activities
- Outdoor Activities
$30
All Day
8.00 AM - 12.30 PM
- 2 meals /day
- Medical Support
- Indoor Activities
- Outdoor Activities
Having any problems? Feel free to get in touch with us
How to enroll step-by-step
Application
Aenean et est tristique, dictum lorem vel, porttitor urna. Nullam vitae urna consequat, condimentum est vitae, mollis nulla.
Counseling
Aenean et est tristique, dictum lorem vel, porttitor urna. Nullam vitae urna consequat, condimentum est vitae, mollis nulla.
Admission
Aenean et est tristique, dictum lorem vel, porttitor urna. Nullam vitae urna consequat, condimentum est vitae, mollis nulla.
Wonderland's Timetable
- Monday
-
Busy Bees
Drawing
8.00 AM 9.30 AM
Teacher: Megan Kelly -
Busy Bees
Drawing
8.00 AM 9.30 AM
Teacher: Megan Kelly -
Busy Bees
Drawing
8.00 AM 9.30 AM
Teacher: Megan Kelly
- Tuesday
-
Happy Tigers
Drawing
8.00 AM 9.30 AM
Teacher: Megan Kelly -
Happy Tigers
Drawing
8.00 AM 9.30 AM
Teacher: Megan Kelly -
Happy Tigers
Drawing
8.00 AM 9.30 AM
Teacher: Megan Kelly
- Wednesday
-
Fantastic Frogs
Drawing
8.00 AM 9.30 AM
Teacher: Megan Kelly -
Fantastic Frogs
Drawing
8.00 AM 9.30 AM
Teacher: Megan Kelly -
Fantastic Frogs
Drawing
8.00 AM 9.30 AM
Teacher: Megan Kelly
- Thursday
-
Happy Hoppers
Drawing
8.00 AM 9.30 AM
Teacher: Megan Kelly -
Happy Hoppers
Drawing
8.00 AM 9.30 AM
Teacher: Megan Kelly -
Happy Hoppers
Drawing
8.00 AM 9.30 AM
Teacher: Megan Kelly
- Friday
-
Happy Hoppers
Drawing
8.00 AM 9.30 AM
Teacher: Megan Kelly -
Happy Hoppers
Drawing
8.00 AM 9.30 AM
Teacher: Megan Kelly -
Happy Hoppers
Drawing
8.00 AM 9.30 AM
Teacher: Megan Kelly
- Saturday
-
Happy Hoppers
Drawing
8.00 AM 9.30 AM
Teacher: Megan Kelly -
Happy Hoppers
Drawing
8.00 AM 9.30 AM
Teacher: Megan Kelly -
Happy Hoppers
Drawing
8.00 AM 9.30 AM
Teacher: Megan Kelly
Meet Our Teachers
What’s New
Storytelling opens the world to discovery
Phasellus at feugiat diam. Etiam eu velit cursus, tempor ipsum in, tempus lectus. Nullam tempus nisi id nisl luctus non tempor justo molestie.
Kids & Chores: The struggle is real
Phasellus at feugiat diam. Etiam eu velit cursus, tempor ipsum in, tempus lectus. Nullam tempus nisi id nisl luctus non tempor justo molestie.
Learning from playing: It's all about fun
Phasellus at feugiat diam. Etiam eu velit cursus, tempor ipsum in, tempus lectus. Nullam tempus nisi id nisl luctus non tempor justo molestie.


I am a software engineer.
I graduated in the Fall 2015 class from Hackbright Academy.
I graduated from Northwestern University with a triple-major in Mathematical Methods in the Social Sciences, Economics, and Anthropology. In my professional career, I strove to challenge myself in roles where I could apply my quantitative and analytical skills. Prior to Hackbright, I was a financial analyst at Wells Capital Management. Now, I aspire to work in an innovative and evolving environment as a software engineer. When I can tear myself away from coding, I can be found jumping around San Francisco in my Kangoo Jumps.
Ever heard of the dating site OkCupid? OKC+ takes OkCupid to the next level with innovative analytics and tools. The OKC+ PostgreSQL database contains 58K profiles that were scraped from OkCupid.
Users can explore the most commonly used adjectives from these profiles on a Google map, and filter results by 22 genders, 12 orientations, and a 80+ year age range.
Alternatively, users can discover how different portions of people’s profiles cluster based on machine learning using a mean shift clustering algorithm, displayed with interactive D3 and Chart.js visuals.
Users can create an OkCupid account on the app, or login with their existing OkCupid credentials to access additional features, such as a messaging bot and a profile generator that uses Markov Chains.


What is pair programming?
Pair Programming is a great way for programmers to put their minds together and collaberate on a variety of projects, challenges, and so forth. When programming alone, everyone has weak points. However pair programming allows you to come together and utilize each others strengths, to come up with the best version.
Why is pair programming important to DBC?
Pair programming is important to DBC, because it allows you to get comfortable working with others. Also taking on different roles allows you to step back and see how another person tackles a challenge and compare it with how you would have done it. All in all, it is also a great learning experience, because every pair programming session, you tend to learn something new from your peer.
Compare Driver and Navigator
While Comparing 'Driver' and 'Navigator: One must take a few things into consideration. Firstly, I will address the 'Driver' Role. As a "Driver" the pair is responsible for physically entering the code, and implementing syntax. This person is also in charge of where the team goes, as far as deciding whether to implement an 'array' or maybe decides a 'hash' would be more appropriate. While in the Navigator role, the pair must take the big picture into consideration, and ensure the 'Driver' isnt headed down any "Rabit-Holes". The Navigator is responsible for interpreting the objective and "Navigating" the pair through the challenge in an efficient and focused manner.
Best Practices while Pair Programming
Pair Programming can be an extremly rewarding, and enjoyable experience. As long as both people involed are courteous of the other pair. We have designed a short summary of "Best Practices" to incorporate into your next pairing session. First, understand you pair is infact not a computer, do not be afraid to ask "how is your day going" or "How are you feeling regarding a certain task/challenge", do not be afraid to humanize the experience. Second, it is the responsibility of each person in the group to contribute, and give their pair the opportuinity to contribute, noone likes a ball-hog, but noone likes a mooch either. Lastly, Enjoy the Session! This should be a fun and rewarding experience. Treat it as such!
Reflection
Peer Programming is a rewarding experience. It allows both the driver and navigator the opportunity to collaborate on best practices. As a pair we were able to leverage each other's strengths to maximize the clarity of material. A strong line of communication kept us on track. It is not best practice to add CSS to the html framework. Seperating the structuring and styling helps the developer stay organized. Additionally, by using a seperate stylesheet document, the developer/team are able to apply the styling format across multiple pages within a website. If the styling is embedded within the structure of the HTML page it will prevent the developer from easily applying their stylesheets to more than one page in a website DOM.