list of X best things do do Blah: an attempt to build a a web game for language learning
Starting at the base
{% endblock %}
my goal throughout this project has been to try and get a proof of concept out to the world as quickly as possibly.
though i want to use the most apt tech at each level, over-engineering is a time suck and generally wasteful knowing the
future will probably hold many changes no matter how perfect something seems to be today.
first up, picking my database.
my rough process:
NoSQl or SQL? welp i don't really feel like learning or dealing with SQL syntax. plus, the rigid format of sql tables
is daunting when my schema is changing every four minutes when i realize another column i forgot to include originally.
okay, nosql it is then. Firebase? i have used this before so i could whip up an api pretty quickly. but did i like it?
it was maybe a little too far from sql without great filtering. maybe i wasn't using it to the best of it's capabilities,
but i felt like i was always pulling way more data than i needed and doing a lot of processing on the clientside (dragggg).
databases i haven't used: mongodb vs rethinkdb
honestly i pretty much just flipped a coin here. i was told that rethink was easy to get up and opperable quickly. beyond
that i didn't need much convincing. i was bored of looking and the 'quickstart' was easy enough to follow.
voilà my database was born.
since picking rethink i have gathered some pros and cons.
pros:
the data console is handy. and the 'tool tips' that come with the suggested commands are super useful.
cons:
some things are missing. i know rethink is meant to just be a blobby store, but since you can access 'tables'
it follows that there would be some sorta of json schema checking included. which i sorely have been missing.
it looked like there was some node module if you are using javascript. but i went with python so no such luck
for me.
impactjs vs craftyjs vs atomicengine
there are about a billion options for game engines
impact is moolah, the tutorial did make it enticing though. just wich i could try before i buy
atomic is 'early access'
giving crafty a try
also looked at:
gamemaker: looks like it isn't being maintained anymore (though i like the ide)
the mac version is pretty poo though and the windows version on parallels is crashing (probs my fault for running on parallels)
finally the first sample game i tried to make wouldn't compile
unity:
seems pretty solid might come back to this
unreal:
paper2d seems cool, but since this is really meant for 3d gonna pass
construct2:
got a working thing up very quickly. seems reasonable. only windows, but don't need licence for now (and they are relatively cheap)
not a bad ide either


All the buildings of Helsinki, each colored by the year it was built in. Click on a buiding to see pictures retrieved from
Finna. You can search for an address or district with the fields below.
Existing buildings based on Helsinki building registry. Demolished buildings digitized from old aerial images, maps and building permits.
Buildings from the Swedish era are mostly speculative as records are scarce. Digitization work made by Christoffer Weckström.
App based on Helsinki building age viewer by Jan Wolski and Helsinki ilmakuvina web app.


{% extends "base.html" %} {% block head %} {% endblock %} {% block content %}
Bookmark this page to come back later, or share this URL with others:
The installers below have been customized by a Seattle user. By running these installers, 10% of your computing resources will be donated to an experiment being run by that user.
{% endif %}Installers are provided for Android, Linux, Mac OS X, and Windows.
Install via Google Play |
Android instructions
To check that Seattle is running, look at the Seattle on Android application window. |
Download installer for Linux |
Linux instructions
To check that Seattle is running, try running: Note: You must have Python 2.5 installed. |
Download installer for Mac |
Mac instructions
To check that Seattle is running, try running: Note: You must have Python 2.5 installed. |
Download installer for Windows |
Windows instructions
To check that Seattle is running, look in Task Manager for the process pythonw.exe. |


Context, Semantics, and Relation
Somewhat of a Philosophical Journey on Meaning
What about AI?
If you read this article, I will save you from wondering "Does Marc know what he's talking about?" The answer is "Probably not." I ask myself questions and I get answers within the context of my experiences as a programmer and human being. In some cases, I frame my questions in a non-technical way to people who have no computer literacy and I'm always fascinated by the responses -- often they are quite illuminating. I did this with parts of this article and was surprised by the similarity in answers. If I convince you that my answers are at least half-truths, then it is probably only because we share some similar contextual frame of reference.
Semantic: "relating to meaning in language or logic."
Context: "the circumstances that form the setting for an event, statement, or idea, and in terms of which it can be fully understood and assessed.'
Relation: "the way in which two or more concepts, objects, or people are connected; a thing's effect on or relevance to another."
And for whom is the meaning relevant? Meaningful data is important to three entities:
Some examples:
We use a MIME type in an HTTP response to help the browser render the data, which can take various forms such as audio, image, text, HTML, and so forth. Oddly enough, MIME stands for "Multipurpose Internet Mail Extensions" and thus the acronym's meaning has been distorted.
The programmer needs to associate meaning to data contained in variables, databases, protocols, and so forth. Bugs often result when a programmer fails to convey the meaning of the data, or worse, the actual meaning of the data is different than its associated "label" which happens all to often when a column in a database table ends up being repurposed for some other data but the column name isn't changed.
And of course, the user must be able to associate data and meaning both to the data being entered and the data being displayed. This is most often done by placing labels next to input/output fields, but other kinds of data visualizations relate meaning, particularly with regards to relationship, in an intuitive way.
It is of interest to note that much of programming involves the manipulation of context, meaning, and relation between different programs and between the program and the user.
One of the simplest ways for a piece of data to have some meaning is through the container's name,
particularly when the container is a native type like string
. For example, these two fields
have meaning to us as the programmer::
string city; string state;
However, because the two fields above do not have meaning to the machine, it is possible to code this mistake:
GetWeatherFor("San Francisco", "CA");
void GetWeatherFor(string state, string city) {...}
Here the implementation accidentally reverses the city and state. The lack of meaning can be particularly confusing when we only have the data values from which to extract meaning, for example:
GetWeatherFor("New York", "New York");
which is the city, and which is the state? Did you also notice that I changed the state from a two letter abbreviation to its full name? Here we have two different representations for the same semantics, that being "state." Which of course is only valid in certain context (i.e., countries) but we'll get to that later.
With Object Oriented Programming, the class, being a container, conveys meaning to both the programmer and the program -- at least for languages that support some level of reflection where the program can determine type information and name. For example, we could write:
class Location { string city; string state; }
The above gives both the programmer and the program some basic meaning to what is being contained. But the meaning of the container type is nebulous. Consider these alternatives:
class Location { decimal latitude; decimal longitude; decimal altitude; } |
class Location { decimal x; decimal y; decimal z; } |
class Location { decimal distance; decimal elevation; decimal azimuth; } |
Not only is the more concise meaning of the coordinate system determined by the context of the labels of the native types that they contain, but the orientation (is a positive angle measured clockwise or counter-clockwise, and from what ordinal direction?) of coordinate system is completely lacking.
So, we begin to see some problems:
Going back to the city/state example, these would perhaps be better implementations (ignoring the implementation details):
class USLocation { City city; State state; } class State { FullName name; StateAbbr abbr; }
The advantage we start to gain here is that not only does the semantics of the type convey meaning but, being now a concrete "thing" from the perspective of the programming language, various rules and validations can be implemented as well. It's also interesting to note that by shifting the semantics to the type (going from native meaningless type to strong type) the importance of the container's name is reduced to essentially ensuring uniqueness. This form also ensures type correctness, as this pseudo-code results in a compiler error in a strongly typed language:
City someCity = "New York"; State someState = "NY"; GetWeatherFor(someCity, someState); void GetWeatherFor(State state, City city) {...}
This is the predominant reason that I have against duck-typed languages -- in a duck-typed language, the programming mistake above might not even result in a runtime error!
The above examples have very generic meaning because there's no context (a form of relationship) with which to associate a Location. Even the meaning of what type of location (granted, easily corrected by being more specific in the name of the Location class) has to be gleaned from the semantics (the fields) of the class itself. We can say a couple things about context:
As a trivial example, if we rewrite the Location class like this:
class CelestialCoordinate { Distance distance; Elevation elevation; Azimuth azimuth; }
we can say that in this case, the context of a celestial coordinate requires
(the how) a distance, elevation, and azimuth. Conversely, if we
look at one of the fields, say azimuth, we can identify that context (the who)
in which azimuth is used -- the type CelestialCoordinate
.
Context is relation because context requires two or more things to be in relationship with each other. Without context, the meaning of some thing is basically unknown and is therefore, if not useless, at least pointless.
Therefore, the meaning of a "thing" must describe not only the thing itself but the context of that thing -- at least one other thing in which it is in relationship. The OOP "has a" relationship is a very important context when working with data semantically. Let's take a look at this example:
USLocation location; class WeatherForecast { USLocation location; Forecast[] fiveDayForecast; } class Forecast { USLocation location; Date date; Conditions conditions; }
Here we have a context-less field called location
as well as a
field of the same type in the context of a WeatherForecast
.
Lastly, we see location
again in the context of each day in a five day forecast.
You should appreciate the complexity of naming things at this point and
the fact that I'm not too concerned (nor skilled) with precise naming at the moment. What is
important is that if we have an agent that operates on the type USLocation
,
it most definitely needs to know the context in which to activate the
processing.
When I wrote about context above, I was referring to context that is obtained by inspecting the containment relationship "has a" and "is a member of." There are obviously relationships that are not containment but rather are expressed in some other association terminology. Example include "owns [something]", "married [to someone]", "lives [somewhere]", "committed [a crime]", "likes [some food]", "likes [some movie]", etc. Each entity in the brackets is itself a semantic entity, and the relationship is also semantic, in that the word has a specific meaning. We rarely express these relationships semantically in code. Our code typically looks like this:
class Employee { Person emergencyContact; Person insuredSpouse; Person[] insuredChildren; Person beneficiary; Person supervisor; }
These are all relationships where the program has no way of understanding the
semantics of the relationship. It's quite possible that under certain
conditions, neither the user nor the programmer even understands the semantics
of the relationship! And of course, this kind of coding creates monolith
applications that eventually are rewritten because extending them breaks so many
other things. And of course, the use of Person
as the container where the
label provides the meaning for each Person
, well, this is also not semantic very useful. Unfortunately though, it is where abstraction,
one of the tenets of OOP, has taken us.
My conjecture is that abstraction should only be applied to behaviors and specialization should be applied for types.
So instead, we might have (at least one iteration toward better semantics):
class Employee { EmergencyContact emergencyContact; InsuredSpouse insuredSpouse; InsuredChild[] insuredChildren; Beneficiary beneficiary; Supervisor supervisor; }
Just as specification creates meaning, so does abstraction create meaning.
It is meaningful to categorize bats, beetles, and ants as "bugs" (at least
Calvin does) because it creates a general context that is particularly useful
for searching and creating generalized hypotheses about two or more things,
which of particular importance with regards to learning -- the process of
generalizing, testing the fit, re-categorizing when a generalization fails is
how we go about balancing specification with generalization in order to function
meaningfully in the world. In the above example, each of the types on the
left might be derived from Person
:
abstract class Person {...} class EmergencyContact : Person {...} class InsuredSpouse : Person {...} class InsuredChild : Person {...} class Beneficiary : Person {...} class Supervisor : Person {...}
And I note that a beneficiary might not be a person but rather, say, a
charity or non-profit organization, which reveals limitations on our hard coded
model. More on that later. None the less it gives us the ability to start with an abstraction
like "Person" and ask "What are the fields in the Employee
class that are
"people?" We can begin to extract meaning from the semantics of
an object model with meta-level queries, having nothing to do with the actual
data contained in those objects.
In the above examples, the context, relationship, and abstraction is
hard-coded. As we saw with Beneficiary
, we could argue that
this is a coding error as beneficiaries are not always people. Context and
abstraction are types of relation that can be extracted into a more pliable
meta-level. If we think about it, the implicit relationships that are
hard-coded are also extractable into a meta-relationship.
Context, and perhaps I'm oversimplifying, can be thought of as a collection of things. Each thing in the collection has a shared context for the simple fact that other things are in the same collection. A simple implementation is trivial:
class Context { List<IEntity> entities; public Add(IEntity entity) {entities.Add(entity);} }
where, using the weather forecast example:
class USLocation : IEntity { Context context; ... } class Forecast : IEntity { Context context; ... } Context GetForecast() { Context context = new Context("5 Day Forecast"); context.Add(new USLocation(context)); context.Add(new Forecast(context, Day._1)); context.Add(new Forecast(context, Day._2)); context.Add(new Forecast(context, Day._3)); context.Add(new Forecast(context, Day._4)); context.Add(new Forecast(context, Day._5)); return context; }
This is a soft-coded context, and note that each entity is given the context
in which it exists. This is necessary so that the entity itself can query
about its context -- if I have a USLocation
instance, I can ask it "in what
context do you live?" and it can "reply" with its context, in
this case "5 Day Forecast." When we hard-code the object model, we're
almost always creating not only immutable contexts, but contexts that can be
understood only by inspecting the code. Here instead, we've named the
context (yes, using a string, there are better options) and we can even build
rules that verify what the context contains. And to really make matters
complicated, the name of the context itself can have contextual information like
"a 5 day forecast is a kind of forecast."
The above example eliminates the container WeatherForecast
and
starts to fly against the gale of object oriented programming tenets. We
start to lose compile-time type checking, code that utilizes the entities in the
context becomes more obtuse and therefore less readable / maintainable and
overall is probably not the direction one would normally go unless from the
get-go you needed a general purpose container. So there are tradeoffs, and
given that I'm not aware of a programming language (my experience is however
quite limited) that helps maintain
compile-time checking, ease of access and readability, the idea of programming
in this form is understandably not what a programmer would normally do.
There's some interesting ways around this which I'll explore later.
An odd heading, but what I mean is extracting out the explicit relationship from the property and making it explicitly. Earlier we saw this:
class Employee { EmergencyContact emergencyContact; InsuredSpouse insuredSpouse; InsuredChild[] insuredChildren; Beneficiary beneficiary; Supervisor supervisor; }
Here the relationships are implicit in the types. What we can do instead is extract out the relationship, which is a common enough practice, perhaps implemented as an enumeration describing the kind of relationship. So we might have something like this:
class RelatedPerson : Person { public RelationshipType relationshipType; }
where:
enum RelationshipType { EmergencyContact, InsuredSpouse, InsuredChild, Beneficiary, Supervisor, }
Notice what then happens:
class Employee { List<RelatedPerson> relatedPeople; // other stuff about the Employee }
It's interesting how this begins to take the form of the Context
example above, at least with regards to the collection of related people.
In "context" form, this might look more like:
context.Add(new Employee(context)); context.Add(new RelatedPerson(context));
Let's do something a bit different though. Instead of an enum expressing the relationship type, let's use actual types:
// General purpose relationship: class Root : IRelationship {} class HasA : IRelationship {} class KindOf : IRelationship {} // Using the employee example: class EmergencyContact : IRelationship {} class InsuredSpouse : IRelationship {} class InsuredChild : IRelationship {} class Beneficiary : IRelationship {} class Supervisor : IRelationship {}
There really is no implementation, we're simply declaring a type. We then define the relationship of objects within a context:
Context context = new Context("Employee"); var employee = new Employee(context); context.Add(employee); // default is Root relationship context.Add<EmergencyContact>(new Person(context), employee); context.Add<InsuredSpouse>(new Person(context), employee); context.Add<InsuredChild>(new Person(context), employee); context.Add<Beneficiary>(new Person(context), employee); context.Add<Supervisor>(new Person(context), employee);
And oh my goodness, we are no longer restricted to using a person as a beneficiary, because we can do this:
context.Add<Beneficiary>(new NonProfitBusiness(context), employee);
Notice in these examples the generic parameter defines the relationship type and, in addition to the object in the context, we also provide the object to which it is related. The Add method signature would look something like this:
void Add<T>(IEntity entity, IEntity relatedEntity) where T : IRelationship {...}
The implementation details are trivial.
One of the issues with the code earlier illustrating abstraction:
class EmergencyContact : Person {...}
is that C# implements single-inheritance, not multiple-inheritance. While many abstractions are in the form of a single-inheritance hierarchy, multiple inheritance can on occasion be useful. However, one can also get into a mental logjam confusing relationship as abstraction. This (if it were possible):
class EmergencyContact : Person, Relative {...}
seems like it describes two abstractions but actually only Person
is an
abstraction. Relative
is a relation, no pun intended.
True abstractions are actually very hard to determine for two reasons:
Regarding #2, perhaps somewhere in the type system exists a taxonomic ranking (excluding subphylum, subclasses, superorders, and subfamilies):
class Animalia : Eukarya {} class Chordata : Animalia {} class Mammalia : Chordata {} class Primates : Mammalia {} class Hominidae : Primates {} class Homo : Hominidae {} class Homosapiens : Homo {} class Person : Homosapiens {}
Heck, why not?
Regarding #3, in programming, we often use multiple inheritance (at least in languages like C++) to acquire behaviors implemented by the abstractions. In languages like C#, we get the behaviors of one abstract class and then have to use interfaces to define additional behaviors, but those must be implemented by the child class! Regardless, the abstractions are purely for the convenience of the programmer and do not necessarily represent true "type" abstractions but rather behavior inheritance. I am not interested in behaviors here because this is exactly what we're teasing out of the class definition! In this theoretical model, a class is nothing more than container for types that ultimately are implemented by native language types.
As an aside, while type abstraction provides useful meaning in terms of generalization and categorization, does behavioral inheritance provide any meaning? More generally, does behavior (functions and methods!) provide meaning? This is a very complex question. For example, it is often the case that the behavior of the C-level people in a company creates the cultural meaning for that company, however, to put it very simplistically (but with a good analogy to programming) I will take that position that behavior is actually a form of communication. When something behaves in a certain way, it creates "messages" that can be used to understand the environment and construct a local reality. (I've been reading about Symbolic Behavior and probably wildly misinterpreting what I've been reading.) This actually works well as an analogy with languages like SmallTalk where all "behaviors" (methods) are actually messages to a class' matching methods.
Here potentially is a valid multiple-inheritance type abstraction:
class Chair : Furniture, Seat {}
Not all pieces of furniture are seats, and not all seats are pieces of furniture. This helps us to create a concrete definition of a true type abstraction: The base types must be capable of mutual exclusion. If one type is completely inclusive of the other type, then the abstraction can be represented hierarchically rather than as sibling abstractions. Maybe you're better at thinking of these kinds of abstractions than I am -- it took me quite a few minutes to come up with that example.
Interestingly, while we managed to include relationship in our context (because relationship between concrete things is itself concrete), we should ask the question "Is abstraction independent of context?" Again, this is a tricky question. There are some abstractions that may be truly independent of context (like Person and its taxonomy) while other abstractions are highly specific to the context. Here's the idea. Given:
context.Add<InsuredSpouse>(new Person(context), employee); context.Add<InsuredChild>(new Person(context), employee);
We want to guarantee that the relation InsuredSpouse
references an actual
Spouse
with an abstraction of Person
, and that the relation InsuredChild
references an actual Child
with an abstraction of Person
.
So we just discovered something: relationships have rules! More on
this later, but for now, we need to be able to support both contextual
abstraction and context-independent abstraction. It seems simple enough to
do this:
class Spouse : Person {} class Child : Person {} context.Add<InsuredSpouse>(new Spouse(context), employee); context.Add<InsuredChild>(new Child(context), employee);
In a different context, it may be irrelevant that Spouse
is a Person
and may have a different kind of abstraction. (We may want to look explore
overloading the type system system at some point.) If we want to be a bit
more dynamic about it, we might want to consider these two use cases:
class Spouse : IEntity {} class Child : IEntity {} class Person : IEntity {} Global.AddAbstraction<Spouse, Person>(); Global.AddAbstraction<Child, Person>(); // or... context.AddAbstraction<Spouse, Person>(); context.AddAbstraction<Child, Person>();
Let's play with what encoding some relationship rules might look like:
context.Relationship<InsuredSpouse>().MustBe<Spouse>(); context.Relationship<InsuredChild>().MustBe<Child>(); context.Relationship<Beneficiary>().CanBe<Person>().OrCanBe<NonProfitBusiness>();
At this point, you're probably experiencing the "Marc is going crazy" effect, others may start wondering if I'm reinventing a rule inference engine. Probably the former, not intentionally the latter. If it helps, where I'm trying to get to is a concrete type system that doesn't rely on metadata attributes to convey context, relationship, and abstraction, but is still extensible 1) without changing the original code and 2) at runtime with dynamically loaded modules.
In the above examples, I've created a context that is populated with concrete
objects. Given that the Context
class is just a container for
IEntity
objects: List<IEntity> entities;
the Context
has no knowledge
of what it is supposed to contain. Let's do that now. The use
case examples might look like this:
context.Declare<Employee>().OneAndOnlyOne(); context.Declare<Person, EmergencyContact>().OneOrMore(); context.Declare<Person, InsuredSpouse>().ZeroOrOne(); context.Declare<Person, InsuredChild>().ZeroOrMore(); context.Declare<Person, Beneficiary>().Min(1).Max(2); context.Declare<Person, Supervisor>().Min(1).Max(3);
Given this, the context "knows" that it must have:
Now we have discovered something - we can have rules:
And most importantly, we can infer a context from disparate data elements that fit the rules of the context and the entity relationships. This gives us a pass/fail criteria or we can assign a "completeness" of the data matching a particular context based on how well the data fits that context. This can be a useful property of a context when performing pattern matching. However, in our use-case example:
context.Add<InsuredSpouse>(new Spouse(context), employee);
we have a problem -- this pseudo-code requires that the Spouse
instance
accepts as an constructor parameter the context in which it lives. This
does not work at all if we want to support free-floating data that we attempt to
fit into different contexts. Thankfully we haven't coded anything yet, the
code examples so far are just hypothetical pseudo-code and we've just discovered
a flaw in the pseudo-code! Besides, requiring that the constructor of
every IEntity
implementer accept a Context
parameter was just ugly, so it's good
to be fixing this, and fixing it for a justifiable reason.
Yes - we can definitely use this architecture to classify a "thing" by the the "things" that can be associated with its context. However, as a classification system it's incomplete because so far all we've created is the ability to classify something by the type -- relationship type and instance type. We do not yet have the ability to qualify a context by entity value.
What is imagination? We could say that imagination is the loosening of the constraints of a context, allowing things that normally do not fit within a context match with a "looks like..." construct. So, for example, we can look at a cloud and come up with all sorts of imaginations of what the cloud looks like by loosening the requirements for context matching.
TODO: Loosening context constraints by value.
We may have a known context for a "mode of transportation" from which "automobile" is derived, identified by discrete items such as wheels and windows. When presented with a bicycle which has wheels, this partially fits "automobile" and the knowledge system can ask "it doesn't look like a car but is it a kind of mode of transportation?"
Sometimes the higher level context is determined by the discrete sub-context.
Other times the higher level context determines the actual concrete sub-context. For example, a person in a business suite in an office is probably a manager or executive. A person in a business suite at a sports event is probably the coach or owner of the team. A person in a business suite sitting at a desk with a country's flag behind him/her is probably the country's leader.
An interesting thing is that as we identify the broader context, we become better at identifying the sub-contexts, and vice-versa.
Sometimes discrete things that don't perfectly fit in a context are identified by other things that do fit. For example, a few oranges are ripe helps to identify that the other un-ripe objects are also oranges.
Once a context exists, it becomes suitable for inclusion in a larger context.
"Hyper-typed"
Relationships have Rules!
Overloading the type system with too many abstraction relationships
Extension methods:
class WeatherForecastContext : Context {} public static USLocation GetLocation(this WeatherForecastContext context) { }
Why use extension methods? Well, because the specialized context type only needs to be declared, not "defined" in terms of its methods. Also, it becomes easily extensible without modifying the specialized type. For example, an extension method could be used to get the 5 day temperature average. Extension methods avoid the whole mess (yes, I just said mess) of derived objects, factories, dependency injection, etc., that are, in my opinion, workarounds to the problems with OOP.
Some notes on abstractions:
https://stackoverflow.com/questions/573913/a-use-for-multiple-inheritance
http://www.thefirstscience.org/is-there-an-alternative-to-abstraction/


Testimony house GRA P.O Box 4824, ilorin, kwara state, Nigeria
Loanplus educational lоаnѕ mау be аblе to hеlр уоu pay fоr your еduсаtіоn (lеѕѕ оthеr fіnаnсіаl аіd), including аll еlіgіblе еduсаtіоn-rеlаtеd еxреnѕеѕ, ѕuсh as tuition, hоuѕіng, bооkѕ, a laptop, lаb fееѕ, аnd mоrе.
If you’re іn thе mаrkеt for a lоаn, wе encourage уоu to gіvе uѕ a саll or come in for a chat. If уоu prefer tо соmmunісаtе еlесtrоnісаllу, рlеаѕе fіll out thіѕ соntасt form, and a bank representative wіll get in tоuсh wіth уоu shortly. At Loanplus, wе understand thе lосаl and international market аnd wе care аbоut our customers fіnаnсіаl wеll-bеіng!
You need to be sure there isn't anything embarrassing hidden variations of passages of Lorem Ipsum available but the majority have suffered alteration in some form, by ended injected humour.
Car lоаn tеrmѕ vаrу from оnе to five уеаrѕ аnd will bе determined, along wіth your rерауmеnt amount аnd rеgulаrіtу, at thе bеgіnnіng оf уоur contract. You аrе then rеquіrеd to рау оff thе lоаn in thе ѕресіfіеd time. If уоu fаll bеhіnd on your rерауmеntѕ уоu wіll bе required to make a lump sum рауmеnt at thе еnd of thе loan tеrm, which іѕ whеrе ѕоmе borrowers саn gеt into ѕtrіfе and rеԛuіrе refinancing.
If you are going to use a passage of Lorem Ipsum, you need to be sure there isn't anything embarrassing hidden variations of passages of Lorem Ipsum available, but the majority have suffered alteration inlined some form, by ended injected humour, or randomised words which don't look even slightly.
Need to be sure there isn't anything embarrassing hidden variations of passages of Lorem Ipsum ailable, but the majority have suffered alteration inlined some form.
If you are going to use a passage of Lorem Ipsum, you need to be sure there isn't anything embarrassing hidden variations of passages of Lorem Ipsum available, but the majority have suffered alteration inlined some form, by ended injected humour, or randomised words which don't look even slightly.
Need to be sure there isn't anything embarrassing hidden variations of passages of Lorem Ipsum ailable, but the majority have suffered alteration inlined some form.
If you are going to use a passage of Lorem Ipsum, you need to be sure there isn't anything embarrassing hidden variations of passages of Lorem Ipsum available, but the majority have suffered alteration inlined some form, by ended injected humour, or randomised words which don't look even slightly.
Need to be sure there isn't anything embarrassing hidden variations of passages of Lorem Ipsum ailable, but the majority have suffered alteration inlined some form.
2021. Frankenstein services, All Rights Reserved


{% extends "base.html" %}
{% load mezzanine_tags %}
{% load url from future %}
{% block meta_title %}Questions & Answers{% endblock %}
{% block body_id %}question-list{% endblock %}
{% block main %}
Have a question about a Raspberry Pi project you are working on? Find or ask questions, plus submit answers too!Questions & Answers


This is the resource website for the June - August 2014 Front End class in Durham, NC. In these pages you'll find resources, setup guidelines and schedules for the class.
This page outlines the daily and weekly schedule for the class.
Find all the resources you'll need to get your local development environment setup, accounts to sign up for and optional productivity tools we'll be suing throughout the class.
A list of articles, books and tutorials you might find useful for helping you hone your front end developer skill set.
A set of policies, guidelines and general expectations we have for our students at The Iron Yard.
Contact information for your instructor, campus director and emergency contacts.


Barillas is located on the Bahia de Jiguilisco, the entrance of which is about 75NM from Cutuco. This quiet Bahia is one of the best cruising grounds on the West Coast of El Salvador and a haven for wildlife.
Position 13° 15.7' N, 88° 25.2' W.
Clearance is straightforward and can be made with Customs and Immigration at the marina who will come to the boat to do all the paperwork.
Last updated May 2016.
The marina is approximately 10NM from the entrance of Bahia Jiquilisco.
Call the marina one hour in advance of your arrival at the channel entrance - by phone is the best bet. A panga will come out and accompany the yacht over the bar up the channel to the marina - daylight hours only. The service charge is included in the first night's mooring fee (see comments below for latest reported fees).
Provisioning can be done in Usulutan which is 20 minutes driving away. The marina provides a free van service on Tuesdays and Fridays. Marine parts must be obtained from San Salvador.
Last updated May 2016.


Stone Breaker is ad-free, however building and maintaining the app and this website take up a lot of time and money. Support the developer via Paypal Here.
Stone Breaker is built on Firebase's mobile app development platform. Stone Breaker also runs on the Google Cloud Platform. See more here.
Stone Breaker uses Google Firebase Machine Learning to analyze faces, recognize landmarks, find smiles, and label images. This app also includes a QR Code Reader that implements Google Cloud Vision API technology for fast readings. Also included is a Random Password generator. Stone Breaker features all of this while being Ad-free! Being among the first apps to fully implement features of the Firebase Machine Learning Kit. Stone Breaker is a trailblazer in bringing powerful Machine Learning technology to your phone! Stone Breaker also makes select features open-source. The Password Generator and Face Analyzer are both available on GitHub. Stone Breaker’s version of Face Analyzer gives more information about the face in the photo to the user; originally it gave the probability of a smile and percentage each eye was open. This version gives the image location of every major facial feature. Of course, features are always being improved upon so stay tuned!


PICS: Demi-Leigh, DJ Tira and David Kau support Charlize Theron at her fundraiser in New York
Graye Morkel
Cape Town - South African celebrities Demi-Leigh Nel-Peters, DJ Tira and David Kau, stepped out on Tuesday, to support Charlize Theron at her Africa Outreach fundraiser in New York.
Aside, from the familiar local faces, the Oscar-winning actress was also joined by celebrity friends like Amy Schumer, Drew Barrymore, and Awkwafina.
The Charlize Theron Africa Outreach Project (CTAOP) invests in African youth and their ability to keep themselves safe from HIV/AIDS. Charlize created CTAOP in 2007 with the hope of making a difference in fighting HIV in South Africa.
Demi-Leigh shared a video of Charlize talking about the theme of the evening, ubuntu. "I am because you are. It's a belief in our universal bond as humans that we're all interconnected," Charlize explained.
The Bombshell actress also shared a video of Boyz II Men performing at fundraising and called it the "highlight of her life."
"Such a great evening supporting the Charlize Theron Africa Outreach Program that benefits so many women back home in South Africa," Demi-Leigh captioned an Instagram photo.


MICHELENE T. H. CHI, NICHOLAS DE LEEUW, MEI-HUNG CHIU AND CHRISTIAN LAVANCHER
Unread
Provides pedagogical evidence that activities which promote the act of explaining something improves your understanding of it. Relevant for the pedagogical aspect of firmware co-design workshops.
"Learning involves the integration of new information into existing knowledge. Generating explanations to oneself (self-explaining) facilitates that integration process."


My name is .
I live in .
My phone number is.
My email is.
Date of birth: I was born.
Marital status: I am married to.
Nationality: My country is.
Languages: My language is.
Sex: I identify as.
I am good at, although I can
I believe that.
I once, but I am.
I am trained in, and I can.
Please hire me. I need, so I can buy.
Thank you for! I hope that.


"I think software can help us go faster here but I don't know how to make it happen."
Technology moves quickly and you have a business to run. Moving faster is key to keeping your customers happy. We can help you with that.
Technology moves quickly and you have a business to run. Moving faster is key to keeping your customers happy. We can help you with that.
Outcomes are important, and software can help achieve good outcomes for your business and customers. We believe in outcome-based software, and we'll help you acheive your goals.
The majority of small business software teams learn on the job. We can help you by working with your team, identifying areas to improve in, and giving actionable advice to make your team deliver better software.


?
For All Views
right/left arrow:
forward/backward in time
up/down arrow:
zoom in/out
space bar/double click:
change between the channels
'A','S','D','W':
rotate in 3D
x
Visible Channels
Strength: 100%
nuclei
Strength: 100%
dpERK
Strength: 100%
twist
Strength: 100%
dorsal
Strength: 100%
ind
Strength: 100%
rhomboid
Motion
playback
0.00 / 0.00
2x
speed
Speed: 2
auto-orbit
View
Orthoslices
xy plane
0.0000mm
yz plane
0.0000mm
xz plane
0.0000mm
1
zoom
Rotation
x axis
0°
y axis
0°
z axis
0°


An ERP user has two options to obtain data for financial journal entries into the ERP:
We recommend using data from FIS whenever possible due to the efficiency and advantages it has over batched extract files. If a customer’s ERP requires a file you will create a file based on FIS data, not the extract.
Using FIS data for either of the above situations will simplify processes and enable FIS benefits.
FIS has these benefits over the Extract file process:
FIS requires a post of the status of the ERP integration back into the SAP Concur solution, per report or invoice. If there is a failure at the ERP, the app will update the affected report or invoice with an error message. The customer will initiate corrective action from within the SAP Concur processor tool. The result is that no expense report or invoice will advance until it can be integrated into the ERP. This process is a change for existing SAP Concur customers who are not accustomed to this awareness between their ERP and SAP Concur solutions.
For existing SAP Concur customers, enabling FIS also requires change management discussions regarding expense reports and invoices in process during the switch. Any report created after FIS is enabled will flow to FIS and not the extract file. Reports still in process when FIS is enabled will be accounted for only via the extract file. Customers need to manage their existing integration until those reports or invoices are completely processed.
To see the mapping of extract files vs. FIS, review the Standard Accounting Extract (SAE) and/or Payment Request Accounting Extract (PRAE) files.
Quick Connect describes the process customers use to connect their SAP Concur site with an App Center Partner’s Enterprise application. See the separate Quick Connect scope document for details to guide you through the development of this required piece to your certified application.
The flow consists of calling the API in this sequence:
The following are the recommended steps when you create a file based on FIS data prior to importing into the ERP:
The above steps will maintain consistency between the customer’s ERP and their SAP Concur Spend Management service. If they cannot be performed due to error-handling logistics between you and customer, then you can post successes for the file content back into the SAP Concur solution. The customer will handle the errors directly with the ERP. However, their ERP and the SAP Concur data will not be in sync at this point.
The following table describes the expected events and their statuses.
| Sequence | Expected Event | Concur Expense Payment Status | FIS Posting Document Status | ERP | FIS |
|---|---|---|---|---|---|
| 1 | Report is submitted by user and enters workflow | Submitted/Not Paid | Doesn’t exist | Doesn’t exist | NA |
| 2 | Report is “final approved” in Processor workflow step | Processing Payment | Queued and Ready | Doesn’t exist | NA |
| 3 | ERP calls FIS for “ready” posting documents | Processing Payment | Queued and Ready | Received | GET financial documents |
| 4 | ERP calls FIS to acknowledge documents retrieved | Processing Payment | Acknowledged | Acknowledged | POST acknowledge financial documents |
| 5 | ERP Sends Posting Feedback - Failed | Financial Posting Failed | Posting Failed | Posting Failed | POST Posting Feedback |
| 6 | Processor Recalls Report for Posting Corrections | Not Paid | Posting Failed | Posting Failed | N/A |
| 7 | Report is re-submitted with corrections and re-enters workflow (steps 1-4 repeat) | Submitted/Not Paid | Posting Failed | Posting Failed | N/A |
| 8 | ERP Sends Posting Feedback – Success | Paid | Posting Success | Posting Success | POST Posting Feedback |
| 9 | ERP Sends Payment Feedback (Optional) | Payment Confirmed | Payment Confirmed | Paid | POST Payment Confirmation |
Expense
Use the entryreceiptID to obtain a short-lived URL (15 minutes ttl) that can be rendered to obtain the receipt image.
https://www.concursolutions.com/api/image/v1.0/report/{entryreceiptID}
Invoice
Use the requestID to obtain a URL, copy the portion up to the “?” and render the image in a separate browser.
https://www.concursolutions.com/api/image/v1.0/invoice/{requestID}
<Image xmlns="http://www.concursolutions.com/api/image/2011/02" xmlns:i="http://www.w3.org/2001/XMLSchema-instance">
<Id>2A5A2971F671480083FF</Id>
<Url>https://imaginginvoiceupload.concursolutions.com/file/p0085104gigw/92608D9780BAB1DB6CF884CE08C115AA660E198045E42357812E976AD35DB3A7B573A0549B4859A742xxxxx?id=2A5A2971F671480083FF&e=p0085104gigw&t=AN&s=ConcurConnect</Url>
</Image>
Review the timing of the FIS API requests to ensure they are not interfering with the customer administrator’s ability to send an expense report (or invoice) back to the employee prior to ERP integration. This may require the development of a button in the UI of the integration to allow the customer to initiate the FIS process on demand. This would eliminate the need to coordinate the timing.
For example, the SAP Concur workflow typically includes a final approval step that is completed by Finance/Accounting. Once the accountant final-approves a report (or invoice), the report is queued into FIS. If necessary, the accountant can pull this report back and send it back to the employee for adjustment prior to ERP integration, but only if you have not yet picked up the report. So, the process should include awareness of the timing between you and your customer.


|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object javax.swing.plaf.ComponentUI javax.swing.plaf.OptionPaneUI javax.swing.plaf.basic.BasicOptionPaneUI
public class BasicOptionPaneUI
Provides the basic look and feel for a JOptionPane
.
BasicMessagePaneUI
provides a means to place an icon,
message and buttons into a Container
.
Generally, the layout will look like:
------------------ | i | message | | c | message | | o | message | | n | message | ------------------ | buttons | |________________|icon is an instance of
Icon
that is wrapped inside a
JLabel
. The message is an opaque object and is tested
for the following: if the message is a Component
it is
added to the Container
, if it is an Icon
it is wrapped inside a JLabel
and added to the
Container
otherwise it is wrapped inside a JLabel
.
The above layout is used when the option pane's
ComponentOrientation
property is horizontal, left-to-right.
The layout will be adjusted appropriately for other orientations.
The Container
, message, icon, and buttons are all
determined from abstract methods.
| Nested Class Summary | |
|---|---|
class |
BasicOptionPaneUI.ButtonActionListener
This inner class is marked "public" due to a compiler bug. |
static class |
BasicOptionPaneUI.ButtonAreaLayout
ButtonAreaLayout behaves in a similar manner to
FlowLayout . |
class |
BasicOptionPaneUI.PropertyChangeHandler
This inner class is marked "public" due to a compiler bug. |
| Field Summary | |
|---|---|
protected boolean |
hasCustomComponents
This is set to true in validateComponent if a Component is contained in either the message or the buttons. |
protected Component |
initialFocusComponent
Component to receive focus when messaged with selectInitialValue. |
protected JComponent |
inputComponent
JComponent provide for input if optionPane.getWantsInput() returns true. |
static int |
MinimumHeight
|
protected Dimension |
minimumSize
|
static int |
MinimumWidth
|
protected JOptionPane |
optionPane
JOptionPane that the receiver is providing the
look and feel for. |
protected PropertyChangeListener |
propertyChangeListener
|
| Constructor Summary | |
|---|---|
BasicOptionPaneUI()
|
| Method Summary | |
|---|---|
protected void |
addButtonComponents(Container container,
Object[] buttons,
int initialIndex)
Creates the appropriate object to represent each of the objects in buttons and adds it to container . |
protected void |
addIcon(Container top)
Creates and adds a JLabel representing the icon returned from getIcon to top . |
protected void |
addMessageComponents(Container container,
GridBagConstraints cons,
Object msg,
int maxll,
boolean internallyCreated)
Creates the appropriate object to represent msg and
places it into container . |
protected void |
burstStringInto(Container c,
String d,
int maxll)
Recursively creates new JLabel instances to represent d . |
boolean |
containsCustomComponents(JOptionPane op)
Returns true if in the last call to validateComponent the message or buttons contained a subclass of Component. |
protected ActionListener |
createButtonActionListener(int buttonIndex)
|
protected Container |
createButtonArea()
Creates and returns a Container containing the buttons. |
protected LayoutManager |
createLayoutManager()
|
protected Container |
createMessageArea()
Messaged from installComponents to create a Container containing the body of the message. |
protected PropertyChangeListener |
createPropertyChangeListener()
|
protected Container |
createSeparator()
|
static ComponentUI |
createUI(JComponent x)
Creates a new BasicOptionPaneUI instance. |
protected Object[] |
getButtons()
Returns the buttons to display from the JOptionPane the receiver is providing the look and feel for. |
protected Icon |
getIcon()
Returns the icon from the JOptionPane the receiver is providing the look and feel for, or the default icon as returned from getDefaultIcon . |
protected Icon |
getIconForType(int messageType)
Returns the icon to use for the passed in type. |
protected int |
getInitialValueIndex()
Returns the initial index into the buttons to select. |
protected int |
getMaxCharactersPerLineCount()
Returns the maximum number of characters to place on a line. |
protected Object |
getMessage()
Returns the message to display from the JOptionPane the receiver is providing the look and feel for. |
Dimension |
getMinimumOptionPaneSize()
Returns the minimum size the option pane should be. |
Dimension |
getPreferredSize(JComponent c)
If c is the JOptionPane the receiver
is contained in, the preferred
size that is returned is the maximum of the preferred size of
the LayoutManager for the JOptionPane , and
getMinimumOptionPaneSize . |
protected boolean |
getSizeButtonsToSameWidth()
Returns true, basic L&F wants all the buttons to have the same width. |
protected void |
installComponents()
|
protected void |
installDefaults()
|
protected void |
installKeyboardActions()
|
protected void |
installListeners()
|
void |
installUI(JComponent c)
Installs the receiver as the L&F for the passed in JOptionPane . |
protected void |
resetInputValue()
Sets the input value in the option pane the receiver is providing the look and feel for based on the value in the inputComponent. |
void |
selectInitialValue(JOptionPane op)
If inputComponent is non-null, the focus is requested on that, otherwise request focus on the default value |
protected void |
uninstallComponents()
|
protected void |
uninstallDefaults()
|
protected void |
uninstallKeyboardActions()
|
protected void |
uninstallListeners()
|
void |
uninstallUI(JComponent c)
Removes the receiver from the L&F controller of the passed in split pane. |
| Methods inherited from class javax.swing.plaf.ComponentUI |
|---|
contains, getAccessibleChild, getAccessibleChildrenCount, getMaximumSize, getMinimumSize, paint, update |
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Field Detail |
|---|
public static final int MinimumWidth
public static final int MinimumHeight
protected JOptionPane optionPane
JOptionPane
that the receiver is providing the
look and feel for.
protected Dimension minimumSize
protected JComponent inputComponent
protected Component initialFocusComponent
protected boolean hasCustomComponents
protected PropertyChangeListener propertyChangeListener
| Constructor Detail |
|---|
public BasicOptionPaneUI()
| Method Detail |
|---|
public static ComponentUI createUI(JComponent x)
public void installUI(JComponent c)
JOptionPane
.
installUI
in class ComponentUI
c
- the component where this UI delegate is being installedComponentUI.uninstallUI(javax.swing.JComponent)
,
JComponent.setUI(javax.swing.plaf.ComponentUI)
,
JComponent.updateUI()
public void uninstallUI(JComponent c)
uninstallUI
in class ComponentUI
c
- the component from which this UI delegate is being removed;
this argument is often ignored,
but might be used if the UI object is stateless
and shared by multiple componentsComponentUI.installUI(javax.swing.JComponent)
,
JComponent.updateUI()
protected void installDefaults()
protected void uninstallDefaults()
protected void installComponents()
protected void uninstallComponents()
protected LayoutManager createLayoutManager()
protected void installListeners()
protected void uninstallListeners()
protected PropertyChangeListener createPropertyChangeListener()
protected void installKeyboardActions()
protected void uninstallKeyboardActions()
public Dimension getMinimumOptionPaneSize()
public Dimension getPreferredSize(JComponent c)
c
is the JOptionPane
the receiver
is contained in, the preferred
size that is returned is the maximum of the preferred size of
the LayoutManager
for the JOptionPane
, and
getMinimumOptionPaneSize
.
getPreferredSize
in class ComponentUI
c
- the component whose preferred size is being queried;
this argument is often ignored,
but might be used if the UI object is stateless
and shared by multiple componentsJComponent.getPreferredSize()
,
LayoutManager.preferredLayoutSize(java.awt.Container)
protected Container createMessageArea()
addIcon
.
protected void addMessageComponents(Container container, GridBagConstraints cons, Object msg, int maxll, boolean internallyCreated)
msg
and
places it into container
. If msg
is an
instance of Component, it is added directly, if it is an Icon,
a JLabel is created to represent it, otherwise a JLabel is
created for the string, if d
is an Object[], this
method will be recursively invoked for the children.
internallyCreated
is true if Objc is an instance
of Component and was created internally by this method (this is
used to correctly set hasCustomComponents only if !internallyCreated).
protected Object getMessage()
protected void addIcon(Container top)
getIcon
to top
. This is messaged from
createMessageArea
protected Icon getIcon()
getDefaultIcon
.
protected Icon getIconForType(int messageType)
protected int getMaxCharactersPerLineCount()
protected void burstStringInto(Container c, String d, int maxll)
d
.
Each JLabel instance is added to c
.
protected Container createSeparator()
protected Container createButtonArea()
getButtons
.
protected void addButtonComponents(Container container, Object[] buttons, int initialIndex)
buttons
and adds it to container
. This
differs from addMessageComponents in that it will recurse on
buttons
and that if button is not a Component
it will create an instance of JButton.
protected ActionListener createButtonActionListener(int buttonIndex)
protected Object[] getButtons()
protected boolean getSizeButtonsToSameWidth()
protected int getInitialValueIndex()
protected void resetInputValue()
public void selectInitialValue(JOptionPane op)
selectInitialValue
in class OptionPaneUI
public boolean containsCustomComponents(JOptionPane op)
containsCustomComponents
in class OptionPaneUI
|
JavaTM 2 Platform Standard Ed. 5.0 |
|||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
Copyright © 2004, 2010 Oracle and/or its affiliates. All rights reserved. Use is subject to license terms. Also see the documentation redistribution policy.


Extend provides a shorthand for creating subclasses of the class
whose constructor it is attached to.
You can pass in an object that represents the things that
should be added to the prototype (in which case, the special
member 'constructor' if present will become the constructor),
or a function that represents the constructor whose prototype
should be modified, or nothing at all, in which case a new
constructor will be created that calls the superclass constructor.
Parameters:
| Name |
Type |
Argument |
Description |
properties |
object
|
function
|
<optional>
|
an object containing methods to be added to the prototype, or the constructor function, or nothing at all. |
- Source:
Returns:
a constructor function for the newly created subclass.
-
Type
-
function


This is a paragraph
This is a paragraph
This is a paragraph with style italic italic bold bold
Hello link lol
Hello link lol "cat"
Hello from link to everyone reading this
Here's an important anchor link.
line 1 line 2
You can also indent
blocks to display
code or poetry.
Indented code/poetry blocks
can be hard-wrapped.
Or, wrap your code in three backticks:
function codeBlocks() {
return "Can be inserted"
}
You can insert quotes by preceeding each line with
>
.Blockquotes can also contain line breaks.
| Column 1 | Column 2 | Column 3 | Column 4 |
|---|---|---|---|
| default | left | center | right |


Orinda Community Center Building
use the sliders below to set each zone's lambda value
↑ Comfort
Costs ↓
Simulation
_____
_____
_____
_____
_____
Average λ
Average Discomfort
Total $ Saved
Total kWH Saved
Cooling Degree-Hrs
0.50
_____
_____
_____
_____


Installation
Before you begin installing you should determine what your S3C3 Scheme will look like. Familiarize yourself with the basics of the scheme before beginning.
Requirements:
There are several requirements for S3C3 to run. In bulleted form:
- PHP 5.3 or later
- PECL HTTP support
- PHP OpenSSL support
- A way to generate and sign certificates with proper usage settings like XCA
Once you have met all of the requirements and have your certificates ready to go you can copy or move the s3c3 folder to where the web server will serve it out. Make sure to change the ownership of the files to web server user, so it can update configurations when needed.
You will need 2 more directories where the web server has write privileges, that are outside the usual web
document space. One is for logging and the other will hold all the certificates. As an example, we will assume I
have all my certificates and keys ready in the keyexport folder of my home directory:
sudo mkdir /var/s3c3 sudo mkdir /var/s3c3/certificate sudo cp ~/keyexport/* /var/s3c3/certificate/ sudo mkdir /var/s3c3/log sudo chown -R www-data:www-data /var/s3c3
You do not need to worry about the permissions on the certificate store until after you complete the installation, at which time you should verify that they are all, indeed 0400.
Configuration:
Configuration in S3C3 is managed first by a YAML file in app/conf/conf.yml and then, if desired, the token and scheme configurations can be maintained in the database. Creating the configuration file first will save a whole lot of time in terms of installation.
If you look at the sample configuration file (conf.yml.example) you will see a whole mess of comments. You do not need to include the comments in your configuration file; they are there to help you initially set it up.
The configuration file is broken into 7 sections. Each of them are explained in detail here.
Environment Settings [env]
env: deployment: dev config: db local_scheme_name: polo1 debug: level: 5 token: s3c3_debug_token
There are 4 sections in env
with debug
having 2 parts.
deployment
- What kind of deployment this is (development, [
dev
], staging [stage
], or production [prod
]). This software is meant only as a proof of concept, do NOT use this in production environments! This field is not currently used by the application beyond setting up logging targets. config
- Either database [
db
] or file [file
] - this determines where the application looks for the scheme configuration and token settings. Setting this value todb
does not mean you will no longer need the conf.yml file in place! local_scheme_name
- This is the client name for this machine. The client name must match the listener name with a number added at the end. (See Scheme Names).
debug.level
- The debug level. Currently any value over 0 will cause the application to log debug output wherever it is called.
debug.token
- Debug token for use in extended logging.
Database Settings [database]
database: prefix: null dbmaster: driver: mysqli host: masterdb.local port: 3306 user: s3c3 password: gbYygw2EaT9cMtE9Rm7B6gLK defaultdb: s3c3 dbslave: driver: mysqli host: slavedb.local port: 3306 user: s3c3 password: 6VurfGpGAtg7mZLsQ63cn5wV defaultdb: s3c3
There are 3 sections in database
with dbmaster
and dbslave
having
6 subsections each. If your deployment does not use a master-slave replication you can use the same values
for both, otherwise the application will use the values in dbmaster
for read-write connections
and those in dbslave
for read-only connections.
prefix
- A string prefix to put in front of your table names. Not thouroughly tested, may still have some bugs, although the unittest prefixing does work.
dbmaster.driver
- The driver name for your database connection. The application knows about MySQL, PostgreSQL and Sqlite. The mysqli driver is recommended for MySQL, while PostgreSQL uses postgres and Sqlite uses sqlite.
dbmaster.host
- The host that the application will need to connect to in order to connect to the database.
dbmaster.port
- The port on which the database server listens. The default port for MySQL is 3306, and for PostgreSQL is 5432. Note that Sqlite does not listen on a port, and the 'host' name must be the absolute path to the database file.
dbmaster.user
- The user name that has permission to read/write in the S3C3 database.
dbmaster.password
- The user password for the user in
user
, above. dbmaster.defaultdb
- The actual database that the application will use.
dbslave
- Sub-items are the same as for
dbmaster
.
Certificate Settings [certificate]
certificate: store: /var/s3c3/certificates validate: 1
There are 2 items in certificate
.
store
- The absolute path to the directory where the certificates are stored. This directory must be writable by the web server user.
validate
- Whether the application should validate certificates [
1
] or ignore validation [0
]. Note that the application does not currently skip validation.
S3C3 Local Listener Settings [s3c3_local_listener]
s3c3_local_listener: endpoint: 'http://localhost/s3c3/' internal_token: dTuHdJpvkBFzhXEcJyKAspBQ version: 1
There are 3 items in s3c3_local_listener
.
endpoint
- The full url to S3C3 on the local machine. This is used by the LocalClient to retrieve certificates for the Client class, and is used by the Bootstrap module.
internal_token
- A random string used to verify that the client sending the request is doing so from the same local configuration file that the listener is using.
version
- Currently version 1. Not checked, but may be used in later versions.
Logging Destinations [logging]
logging: file: dir: /var/s3c3/log/ mail: to<EMAIL_ADDRESS>from<EMAIL_ADDRESS>sms: to<EMAIL_ADDRESS>from<EMAIL_ADDRESS>There are 3 items in logging
, with mail
and sms
having 2
sub-sections each and file
having only one sub-section.
file.dir
- The directory to which the logging system will write. This directory must be writable by the web server user.
mail.to
- Where should email logs (error warnings) be sent? You can use a single
email address here or an array of addresses like:
to<EMAIL_ADDRESS><EMAIL_ADDRESS><EMAIL_ADDRESS>mail.from
- The address that mail will be sent from.
sms.to
- Where should critical messages be sent? This uses email format to send to SMS, so you can use regular old email addresses here as well. This is only used in a production environment, so is very not likely to be used in this application any time soon.
sms.from
- The address that SMS email will be sent from.
Token Settings [token]
token: expire: 90 length: 64 strength: maximum delete_on_load: 1
There are 4 items in token
.
expire
- Expire time in seconds.
length
- Length of tokens to generate, 32 - 128 characters. Recommend 64.
strength
- There are 4 strength levels to choose from for S3C3 single-use tokens:
weak
: uses only hexadecimal characters [0123456789abcdef]medium
: uses [0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz]strong
: uses [#+-./0123456789=ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz~]maximum
: uses all printable ascii characters (0x20 - 0x7F) except ':' (0x3A) (which is used for token section division) but will not start or end with a space (0x20).
delete_on_load
- Should the application delete expired token strings and mark them
as expired before looking up a token context? [
1
] for yes, [0
] for no. Unless the server you are testing this out on is incredibly busy, the extra overhead of one more database call on token lookup is worth the trouble saved by having to do it via cron job or other method.
Scheme Layout [scheme]
scheme: listeners: polo: 'http://haproxy.polo.local/s3c3/' gold: 'http://gold.local/s3c3/' mac: 'http://vm09.local/s3c3/' clients: [polo1, polo2, gold1, mac1]
There are 2 items in scheme
with listeners
having an arbitrary number of
sub-items.
listeners
- Listeners is a hash of listener names tied to their urls. This is used to let the Client know where to connect when it is told to connect to a listener. Note that the urls do not have to match the names of the listeners, although it would probably be easier for administration if they did in some manner. Urls must either end with a slash '/' or can be extended out to include index.php if the web server does not automatically send directory requests to that file.
clients
- An array of all client names that are allowed to connect to the listeners in this scheme. Notice that even though our sample scheme has 3 machines in the polo pool - only polo1 and polo2 are allowed to connect to other listeners. This is perfectly valid in an S3C3 scheme.
Calling Bootstrap:
Now, you have your conf.yml file, what to do? You have a couple choices: you can (a) let the bootstrap module load the conf.yml to its proper location, or (b) copy the conf.yml file to s3c3/app/conf/conf.yml, change ownership of the file to the web server user and then call the bootstrap module to finalize the installation.
Method (a) first: we will assume that the S3C3 app is installed in /var/www/s3c3 and that the conf.yml file you just completed is sitting in /tmp/conf.yml
cd /var/www/s3c3 sudo php bootstrap/bootstrap.php -af /tmp/conf.yml
That's all it takes. The flag -a
tells the bootstrap module to run on "autopilot" and the flag
-f
tells the bootstrap module to load the configuration file from the filepath that follows the
flag. Note that you can combine flags, as in the example with only one '-'.
The only other flag available to the bootstrap module is -c
which tells it to try and run in
color for xterm or similar. (This will not work in DOS, sorry). This comes in handy for the next method.
Method (b): again we will assume that the S3C3 app is installed in /var/www/s3c3 and that the conf.yml file you just completed is sitting in /tmp/conf.yml. Further, we will assume that the web server username is www-data.
cd /var/www/s3c3 sudo mv /tmp/conf.yml /var/www/s3c3/app/conf/ sudo chown www-data:www-data /var/www/s3c3/app/conf/conf.yml sudo php bootstrap/bootstrap.php -c
This will now start the bootstrap module and it will ask 'Conf.yml already exists, would you like the update
menu? (Y/N)'.
Answer Y (hit Enter, Y is the default) and you will get a menu that looks like:
Answer W and hit Enter and the bootstrap module will do all the same writing and saving that it does in method (a).


- handleAddressBookChangedEvent(AddressBookChangedEvent)
- Method in interface seedu.address.storage.Storage
-
Saves the current version of the Address Book to the hard disk.
- handleAddressBookChangedEvent(AddressBookChangedEvent)
- Method in class seedu.address.storage.StorageManager
-
- handleAddressBookChangedEvent(AddressBookChangedEvent)
- Method in class seedu.address.ui.StatusBarFooter
-
- handleAddressBookChangedEvent_exceptionThrown_eventRaised()
- Method in class seedu.address.storage.StorageManagerTest
-
- handleExitAppRequestEvent(ExitAppRequestEvent)
- Method in class seedu.address.MainApp
-
- handleHelp() - Method in class
seedu.address.ui.MainWindow
-
Opens the help window or focuses on it if it's already opened.
- handleJumpToListRequestEvent()
- Method in class seedu.address.ui.PersonListPanelTest
-
- handleKeyPress_startingWithDown()
- Method in class seedu.address.ui.CommandBoxTest
-
- handleKeyPress_startingWithUp()
- Method in class seedu.address.ui.CommandBoxTest
-
- hasCurrent()
- Method in class seedu.address.logic.ListElementPointer
-
Returns true if calling #current()
does not throw an NoSuchElementException
.
- hashcode() - Method in class
seedu.address.logic.CommandHistoryTest
-
- hashCode()
- Method in class seedu.address.AppParameters
-
- hashCode() - Method in class
seedu.address.commons.core.Config
-
- hashCode() - Method in class
seedu.address.commons.core.GuiSettings
-
- hashCode()
- Method in class seedu.address.commons.core.Version
-
- hashCode()
- Method in class seedu.address.logic.CommandHistory
-
- hashCode() - Method in class
seedu.address.logic.parser.Prefix
-
- hashCode() - Method in class
seedu.address.model.AddressBook
-
- hashCode()
- Method in class seedu.address.model.person.Address
-
- hashCode() - Method in class
seedu.address.model.person.Email
-
- hashCode() - Method in class
seedu.address.model.person.Name
-
- hashCode() - Method in class
seedu.address.model.person.Person
-
- hashCode() - Method in class
seedu.address.model.person.Phone
-
- hashCode()
- Method in class seedu.address.model.person.UniquePersonList
-
- hashCode()
- Method in class seedu.address.model.tag.Tag
-
- hashCode() - Method in class
seedu.address.model.UserPrefs
-
- hasNext() - Method in class
seedu.address.logic.ListElementPointer
-
Returns true if calling #next()
does not throw an NoSuchElementException
.
- hasPerson(Person)
- Method in class seedu.address.model.AddressBook
-
Returns true if a person with the same identity as person
exists in the
address book.
- hasPerson(Person)
- Method in interface seedu.address.model.Model
-
Returns true if a person with the same identity as person
exists in the
address book.
- hasPerson(Person)
- Method in class seedu.address.model.ModelManager
-
- hasPerson_nullPerson_throwsNullPointerException()
- Method in class seedu.address.model.AddressBookTest
-
- hasPerson_nullPerson_throwsNullPointerException()
- Method in class seedu.address.model.ModelManagerTest
-
- hasPerson_personInAddressBook_returnsTrue()
- Method in class seedu.address.model.AddressBookTest
-
- hasPerson_personInAddressBook_returnsTrue()
- Method in class seedu.address.model.ModelManagerTest
-
- hasPerson_personNotInAddressBook_returnsFalse()
- Method in class seedu.address.model.AddressBookTest
-
- hasPerson_personNotInAddressBook_returnsFalse()
- Method in class seedu.address.model.ModelManagerTest
-
- hasPerson_personWithSameIdentityFieldsInAddressBook_returnsTrue()
- Method in class seedu.address.model.AddressBookTest
-
- hasPrevious()
- Method in class seedu.address.logic.ListElementPointer
-
Returns true if calling #previous()
does not throw an NoSuchElementException
.
- help_multipleCommands_onlyOneHelpWindowOpen()
- Method in class systemtests.HelpCommandSystemTest
-
- HELP_WINDOW_TITLE
- Static variable in class guitests.guihandles.HelpWindowHandle
-
- HelpCommand - Class
in seedu.address.logic.commands
-
Format full help instructions for every command for display.
- HelpCommand()
- Constructor for class seedu.address.logic.commands.HelpCommand
-
- HelpCommandSystemTest
- Class in systemtests
-
A system test class for the help window, which contains interaction with other UI
components.
- HelpCommandSystemTest()
- Constructor for class systemtests.HelpCommandSystemTest
-
- HelpCommandTest -
Class in seedu.address.logic.commands
-
- HelpCommandTest()
- Constructor for class seedu.address.logic.commands.HelpCommandTest
-
- HelpWindow
- Class in seedu.address.ui
-
Controller for a help page
- HelpWindow() - Constructor for class
seedu.address.ui.HelpWindow
-
Creates a new HelpWindow.
- HelpWindow(Stage)
- Constructor for class seedu.address.ui.HelpWindow
-
Creates a new HelpWindow.
- HelpWindowHandle - Class in guitests.guihandles
-
A handle to the HelpWindow
of the application.
- HelpWindowHandle(Stage)
- Constructor for class guitests.guihandles.HelpWindowHandle
-
- HelpWindowTest - Class in seedu.address.ui
-
- HelpWindowTest()
- Constructor for class seedu.address.ui.HelpWindowTest
-
- HistoryCommand - Class in seedu.address.logic.commands
-
Lists all the commands entered by user from the start of app launch.
- HistoryCommand()
- Constructor for class seedu.address.logic.commands.HistoryCommand
-
- HistoryCommandTest -
Class in seedu.address.logic.commands
-
- HistoryCommandTest()
- Constructor for class seedu.address.logic.commands.HistoryCommandTest
-
- HOON -
Static variable in class seedu.address.testutil.TypicalPersons
-


| Package | Description |
|---|---|
| org.mockito |
Mockito is a mock library for java - see
Mockito class for usage. |
| org.mockito.invocation |
Public API related to mock method invocations.
|
| org.mockito.junit |
Mockito JUnit integration ; rule and runners.
|
| org.mockito.listeners |
Public classes relative to the listener APIs.
|
| org.mockito.mock |
Mock settings related classes.
|
| org.mockito.plugins |
Mockito plugins allow customization of behavior.
|
| org.mockito.quality |
Mocking quality related classes.
|
| org.mockito.session | |
| org.mockito.stubbing |
Stubbing related classes.
|
| org.mockito.verification |
Verification related classes.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
MockitoFramework
Mockito framework settings and lifecycle listeners, for advanced users or for integrating with other frameworks.
|
interface |
MockitoSession
MockitoSession is an optional, highly recommended feature
that helps driving cleaner tests by eliminating boilerplate code and adding extra validation. |
| Modifier and Type | Method and Description |
|---|---|
MockitoFramework |
MockitoFramework.addListener(MockitoListener listener)
Adds listener to Mockito.
|
static <T,A> Answer<T> |
AdditionalAnswers.answer(Answer1<T,A> answer)
Creates an answer from a functional interface - allows for a strongly typed answer to be created
ideally in Java 8
|
static <T,A,B> Answer<T> |
AdditionalAnswers.answer(Answer2<T,A,B> answer)
Creates an answer from a functional interface - allows for a strongly typed answer to be created
ideally in Java 8
|
static <T,A,B,C> Answer<T> |
AdditionalAnswers.answer(Answer3<T,A,B,C> answer)
Creates an answer from a functional interface - allows for a strongly typed answer to be created
ideally in Java 8
|
static <T,A,B,C,D> |
AdditionalAnswers.answer(Answer4<T,A,B,C,D> answer)
Creates an answer from a functional interface - allows for a strongly typed answer to be created
ideally in Java 8
|
static <T,A,B,C,D,E> |
AdditionalAnswers.answer(Answer5<T,A,B,C,D,E> answer)
Creates an answer from a functional interface - allows for a strongly typed answer to be created
ideally in Java 8
|
static <T,A,B,C,D,E,F> |
AdditionalAnswers.answer(Answer6<T,A,B,C,D,E,F> answer)
Creates an answer from a functional interface - allows for a strongly typed answer to be created
idiomatically in Java 8
|
static <T> Answer<T> |
AdditionalAnswers.answersWithDelay(long sleepyTime,
Answer<T> answer)
Returns an answer after a delay with a defined length.
|
static <A> Answer<Void> |
AdditionalAnswers.answerVoid(VoidAnswer1<A> answer)
Creates an answer from a functional interface - allows for a strongly typed answer to be created
ideally in Java 8
|
static <A,B> Answer<Void> |
AdditionalAnswers.answerVoid(VoidAnswer2<A,B> answer)
Creates an answer from a functional interface - allows for a strongly typed answer to be created
ideally in Java 8
|
static <A,B,C> Answer<Void> |
AdditionalAnswers.answerVoid(VoidAnswer3<A,B,C> answer)
Creates an answer from a functional interface - allows for a strongly typed answer to be created
ideally in Java 8
|
static <A,B,C,D> Answer<Void> |
AdditionalAnswers.answerVoid(VoidAnswer4<A,B,C,D> answer)
Creates an answer from a functional interface - allows for a strongly typed answer to be created
ideally in Java 8
|
static <A,B,C,D,E> |
AdditionalAnswers.answerVoid(VoidAnswer5<A,B,C,D,E> answer)
Creates an answer from a functional interface - allows for a strongly typed answer to be created
ideally in Java 8
|
static <A,B,C,D,E,F> |
AdditionalAnswers.answerVoid(VoidAnswer6<A,B,C,D,E,F> answer)
Creates an answer from a functional interface - allows for a strongly typed answer to be created
idiomatically in Java 8
|
<T> MockCreationSettings<T> |
MockSettings.build(Class<T> typeToMock)
Creates immutable view of mock settings used later by Mockito.
|
void |
MockitoFramework.clearInlineMock(Object mock)
Clears up internal state of specific inline mock.
|
void |
MockitoFramework.clearInlineMocks()
Clears up internal state of all inline mocks.
|
void |
MockitoSession.finishMocking()
Must be invoked when the user is done with mocking for given session (test method).
|
void |
MockitoSession.finishMocking(Throwable failure)
Must be invoked when the user is done with mocking for given session (test method).
|
static MockitoFramework |
Mockito.framework()
For advanced users or framework integrators.
|
InvocationFactory |
MockitoFramework.getInvocationFactory()
Returns a factory that can create instances of
Invocation . |
MockHandler |
MockingDetails.getMockHandler()
Returns the
MockHandler associated with this mock object. |
MockitoPlugins |
MockitoFramework.getPlugins()
Returns an object that has access to Mockito plugins.
|
static LenientStubber |
Mockito.lenient()
Lenient stubs bypass "strict stubbing" validation (see
Strictness.STRICT_STUBS ). |
MockSettings |
MockSettings.lenient()
Lenient mocks bypass "strict stubbing" validation (see
Strictness.STRICT_STUBS ). |
static MockitoSessionBuilder |
Mockito.mockitoSession()
MockitoSession is an optional, highly recommended feature
that helps driving cleaner tests by eliminating boilerplate code and adding extra validation. |
MockSettings |
MockSettings.outerInstance(Object outerClassInstance)
Makes it possible to mock non-static inner classes in conjunction with
MockSettings.useConstructor(Object...) . |
MockitoFramework |
MockitoFramework.removeListener(MockitoListener listener)
When you add listener using
MockitoFramework.addListener(MockitoListener) make sure to remove it. |
void |
MockitoSession.setStrictness(Strictness strictness)
Changes the strictness of this
MockitoSession . |
static <T> T |
Mockito.spy(Class<T> classToSpy)
Please refer to the documentation of
Mockito.spy(Object) . |
MockSettings |
MockSettings.useConstructor(Object... args)
Mockito attempts to use constructor when creating instance of the mock.
|
MockSettings |
MockSettings.verificationStartedListeners(VerificationStartedListener... listeners)
Registers a listener(s) that will be notified when user starts verification.
|
MockSettings |
MockSettings.withoutAnnotations()
By default, Mockito makes an attempt to preserve all annotation meta data on the mocked
type and its methods to mirror the mocked type as closely as possible.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
InvocationContainer
Although this class is a part of public API, please don't provide your own implementations.
|
interface |
InvocationFactory
Available via
MockitoFramework.getInvocationFactory() . |
| Modifier and Type | Method and Description |
|---|---|
Invocation |
InvocationFactory.createInvocation(Object target,
MockCreationSettings settings,
Method method,
InvocationFactory.RealMethodBehavior realMethod,
Object... args)
Creates instance of an
Invocation object. |
InvocationContainer |
MockHandler.getInvocationContainer()
Returns the object that holds all invocations on the mock object,
including stubbings with declared answers.
|
MockCreationSettings<T> |
MockHandler.getMockSettings()
Read-only settings the mock object was created with.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
VerificationCollector
Use this rule in order to collect multiple verification failures and report at once.
|
| Modifier and Type | Method and Description |
|---|---|
VerificationCollector |
VerificationCollector.assertLazily()
Enforce all verifications are performed lazily.
|
void |
VerificationCollector.collectAndReport()
Collect all lazily verified behaviour.
|
static VerificationCollector |
MockitoJUnit.collector()
Creates a rule instance that can perform lazy verifications.
|
MockitoRule |
MockitoRule.strictness(Strictness strictness)
The strictness, especially "strict stubs" (
Strictness.STRICT_STUBS )
helps debugging and keeping tests clean. |
| Modifier and Type | Interface and Description |
|---|---|
interface |
VerificationListener
This listener can be notified of verify invocations on a mock.
|
interface |
VerificationStartedEvent
The instance of this class is passed to
VerificationStartedListener . |
interface |
VerificationStartedListener
This listener gets notified when the user starts verification.
|
| Modifier and Type | Method and Description |
|---|---|
Object |
VerificationStartedEvent.getMock()
The mock object that will be used during verification.
|
void |
VerificationStartedListener.onVerificationStarted(VerificationStartedEvent event)
Triggered when the user calls
Mockito.verify() . |
void |
VerificationStartedEvent.setMock(Object mock)
Replaces existing mock object for verification with a different one.
|
| Modifier and Type | Class and Description |
|---|---|
class |
SerializableMode
Mock serializable style.
|
| Modifier and Type | Method and Description |
|---|---|
Object[] |
MockCreationSettings.getConstructorArgs()
Used when arguments should be passed to the mocked object's constructor, regardless of whether these
arguments are supplied directly, or whether they include the outer instance.
|
Object |
MockCreationSettings.getOuterClassInstance()
Used when mocking non-static inner classes in conjunction with
MockCreationSettings.isUsingConstructor() |
List<VerificationStartedListener> |
MockCreationSettings.getVerificationStartedListeners()
VerificationStartedListener instances attached to this mock,
see MockSettings.verificationStartedListeners(VerificationStartedListener...) |
boolean |
MockCreationSettings.isLenient()
Informs if the mock was created with "lenient" strictness, e.g.
|
boolean |
MockCreationSettings.isUsingConstructor()
Informs whether the mock instance should be created via constructor
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
InlineMockMaker
Extension to
MockMaker for mock makers that changes inline method implementations
and need keep track of created mock objects. |
interface |
MockitoLogger
Mockito logger.
|
static interface |
MockMaker.TypeMockability
Carries the mockability information
|
interface |
PluginSwitch
Allows switching off the plugins that are discovered on classpath.
|
| Modifier and Type | Method and Description |
|---|---|
void |
InlineMockMaker.clearAllMocks()
Cleans up internal state for all existing mocks.
|
void |
InlineMockMaker.clearMock(Object mock)
Clean up internal state for specified
mock . |
MockMaker.TypeMockability |
MockMaker.isTypeMockable(Class<?> type)
Indicates if the given type can be mocked by this mockmaker.
|
void |
MockitoLogger.log(Object what)
Log specified object.
|
| Modifier and Type | Class and Description |
|---|---|
class |
Strictness
Configures the "strictness" of Mockito, affecting the behavior of stubbings and verification.
|
| Modifier and Type | Interface and Description |
|---|---|
interface |
MockitoSessionBuilder
Fluent builder interface for
MockitoSession objects. |
interface |
MockitoSessionLogger
Logger for hints emitted when
finishing mocking for a
MockitoSession . |
| Modifier and Type | Method and Description |
|---|---|
MockitoSessionBuilder |
MockitoSessionBuilder.initMocks(Object... testClassInstances)
Adds the test class instances for initialization of fields annotated with Mockito annotations
like
Mock . |
MockitoSessionBuilder |
MockitoSessionBuilder.initMocks(Object testClassInstance)
Adds the test class instance for initialization of fields annotated with Mockito annotations
like
Mock . |
void |
MockitoSessionLogger.log(String hint)
Logs the hint.
|
MockitoSessionBuilder |
MockitoSessionBuilder.logger(MockitoSessionLogger logger)
Configures logger used by
MockitoSession for emitting
warnings when finishing the session. |
MockitoSessionBuilder |
MockitoSessionBuilder.name(String name)
Configures the name of the
MockitoSession instance. |
MockitoSession |
MockitoSessionBuilder.startMocking()
Starts new mocking session! Creates new
MockitoSession instance to initialize the session. |
MockitoSessionBuilder |
MockitoSessionBuilder.strictness(Strictness strictness)
Configures strictness of
MockitoSession instance. |
| Modifier and Type | Interface and Description |
|---|---|
interface |
Answer1<T,A0>
Generic interface to be used for configuring mock's answer for a single argument invocation.
|
interface |
Answer2<T,A0,A1>
Generic interface to be used for configuring mock's answer for a two argument invocation.
|
interface |
Answer3<T,A0,A1,A2>
Generic interface to be used for configuring mock's answer for a three argument invocation.
|
interface |
Answer4<T,A0,A1,A2,A3>
Generic interface to be used for configuring mock's answer for a four argument invocation.
|
interface |
Answer5<T,A0,A1,A2,A3,A4>
Generic interface to be used for configuring mock's answer for a five argument invocation.
|
interface |
Answer6<T,A0,A1,A2,A3,A4,A5>
Generic interface to be used for configuring mock's answer for a six argument invocation.
|
interface |
ValidableAnswer
Allow to validate this answer is correct for the given invocation.
|
interface |
VoidAnswer1<A0>
Generic interface to be used for configuring mock's answer for a single argument invocation that returns nothing.
|
interface |
VoidAnswer2<A0,A1>
Generic interface to be used for configuring mock's answer for a two argument invocation that returns nothing.
|
interface |
VoidAnswer3<A0,A1,A2>
Generic interface to be used for configuring mock's answer for a three argument invocation that returns nothing.
|
interface |
VoidAnswer4<A0,A1,A2,A3>
Generic interface to be used for configuring mock's answer for a four argument invocation that returns nothing.
|
interface |
VoidAnswer5<A0,A1,A2,A3,A4>
Generic interface to be used for configuring mock's answer for a five argument invocation that returns nothing.
|
interface |
VoidAnswer6<A0,A1,A2,A3,A4,A5>
Generic interface to be used for configuring mock's answer for a six argument invocation that returns nothing.
|
| Modifier and Type | Method and Description |
|---|---|
Strictness |
Stubbing.getStrictness()
Informs about the
Strictness level of this stubbing. |
| Modifier and Type | Interface and Description |
|---|---|
interface |
VerificationEvent
Contains all information about a verification that has happened.
|


Launching an attractive and scalable website quickly and affordably is important for modern startups — Stack offers massive value without looking 'bargain-bin'.


American_Gods
American Gods follows Shadow Moon, a man serving three years in prison who is given an early release. Shadow Moon is hired as Mr. Wednesday's bodyguard and finds himself in a hidden world where a battle is brewing between the Old Gods and the New Gods.


Show Quorums
Cluster
X: 4
slot_9
X: 4
slot_9
X: 4
slot_9
X: 4
slot_9
X: 4
slot_9
Icons made by
Freepik
from
www.flaticon.com


DIVERSÃO
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has b...
Dia:28/10
VER EVENTO
DIVERSÃO
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has b...
Dia:28/10
VER EVENTO
DIVERSÃO
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has b...
Dia:28/10
VER EVENTO
DIVERSÃO
Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has b...
Dia:28/10
VER EVENTO


|
GNSDK C API Reference
<IP_ADDRESS>2
|
Macros | |
| #define | GNSDK_MANAGER_LICENSEDATA_FILENAME (gnsdk_size_t)-2 |
| #define | GNSDK_MANAGER_LICENSEDATA_NULLTERMSTRING (gnsdk_size_t)-1 |
| #define | GNSDK_MANAGER_LICENSEDATA_STDIN (gnsdk_size_t)-3 |
| #define GNSDK_MANAGER_LICENSEDATA_FILENAME (gnsdk_size_t)-2 |
Indicates the provided license data is a relative or absolute path and filename to the license file. GNSDK_MANAGER_LICENSEDATA_FILENAME Passing this value to gnsdk_manager_initialize() for the license_data_len parameter indicates the license_data parameter points to a valid null-terminated string containing the path of a file containing the license data. The file contents are read by the SDK and applied as license data. Example error = gnsdk_manager_initialize(&sdkmgr_handle, "path/my_license.txt", GNSDK_MANAGER_LICENSEDATA_FILENAME);
Definition at line 107 of file gnsdk_manager.h.
| #define GNSDK_MANAGER_LICENSEDATA_NULLTERMSTRING (gnsdk_size_t)-1 |
Indicates the provided license data is a properly null-terminated string. Passing this value to gnsdk_manager_initialize() for the license_data_len parameter indicates the license_data parameter points to a valid null-terminated string containing the full license data. The length of the license data is computed by the SDK. Example error = gnsdk_manager_initialize(&sdkmgr_handle, license_data, GNSDK_MANAGER_LICENSEDATA_NULLTERMSTRING);
Definition at line 93 of file gnsdk_manager.h.
| #define GNSDK_MANAGER_LICENSEDATA_STDIN (gnsdk_size_t)-3 |
Indicates license data is provided through standard input (stdin). Passing this value to gnsdk_manager_initialize for the license_data_len parameter indicates that license data is provided through stdin; in this case, the license_data parameter is ignored. The SDK reads from stdin and applies any received data as license data. Example error = gnsdk_manager_initialize(&sdkmgr_handle, GNSDK_NULL, GNSDK_MANAGER_LICENSEDATA_STDIN);
Definition at line 118 of file gnsdk_manager.h.
How can we improve this topic?
Copyright © 2000-present. Gracenote, Inc. All rights reserved. Generated on Tue Jan 8 2013 07:40:58.


{% extends 'softadmin/base.html' %}
{% block sidebar %}
{% with current_sidebar="services" %}
{{block.super}}
{% endwith %}
{% endblock %}
{% block page_header %}
{% url softadmin/services as refresh_link %}
{# to make searchable false, just remove it from the include statement #}
{% include "_page_header.html" with title="Services" refresh_link=refresh_link searchable="true" %}
{% endblock page_header %}
{% block _main %}
{% include 'softadmin/service_table.html' %}
{% endblock %}