Butcher walks through the dimly lit museum he has curated in a pole barn just beside his house. The items, like a large collection of photos, have come from people in the community, and Butcher keeps a hold on the stories he was told by older people when he was young. He looks upon the collection with reverence, a deep respect for the past of Southeast Ohio and his ancestors who contributed to the history.
The preservation of the culture and the history of Black people in Athens County is something many residents of the region, whether permanent or here for a short time with Ohio University, have never heard of. However, there are many people working to preserve the past and the future of the community.
Butcher has spent his life educating those from around the region on the significance of Tabler Town, also known as Kilvert to many today. In its early days, Tabler Town was a safe town in Ohio for self-emancipated and formerly enslaved people to migrate to.
The People of Color Museum is full of historical items from people who have lived in the region. With these historical items, Butcher tells a story about the arrival of the Tabler family to the United States as well as the history of the town named after them.
Michael Tabler founded Tabler Town circa the 1830s because of his affection for Hannah Tabler, a formerly enslaved woman, and her children. He purchased and emancipated them from slavery, and they lived together in Tabler Town until their deaths.
For Butcher, the town has ties to his family, as Hannah was his eighth great-grandmother, strengthening his connection to the history.
Jesse Jarrold-Grapes | Photo Editor
David Butcher stands at a grave in one of two cemetaries just outside of one of the sites he has curated into a museum to tell the stories of Black history in the region.
However, Tabler Town has been overlooked for years, and people in the region have forgotten the importance of why the name must stay today, Butcher said. The name is tied back to Tabler Town’s roots as a safe place for formerly enslaved people and others who were discriminated against.
Butcher works towards spreading the word of Tabler Town with the People of Color Museum, for the history is much bigger than what is scratched by the surface.
He feels his ancestors bestowed the history to him, and he is dedicated to preserving it, along with their memory. It has laid the foundational, metaphorical land Athens County sits upon today, he said.
“It is not something I studied for, it's not something that was put in a book,” Butcher said. “There's something that your ancestors see in you when you're growing up that makes you the person that you are. So I was always listening to old people, always listening to their stories. People giving me items (like) ‘Here, keep this,’ ‘Here, I want you to have this.’ I've done very well, but I'm getting older. And it's up to me, not just me, but other family members as well, to see that this history is passed on to the next generation.”
All of these experiences growing up inspired him to create the People of Color Museum to honor and preserve the memory of people of color in the region.
“The long term goal of People of Color Museum is to establish a new museum in Tabler Town that will be there to help continue this story, and help the community,” Butcher said. “It will be self-sustaining.”
Butcher believes that the memory of his ancestors has been passed on to younger generations, like his nephews, Kitton Butcher and Christopher Butcher, niece, Joanna Flowers, and Brianna Walker, a young woman residing in Tabler Town, and he hopes others find the willingness to learn and preserve the history as well.
The People of Color Museum is only one example of a resource on Black history in Athens County. The area has a number of other historical places to learn more about a relatively unknown history.
On North Congress Street stands Mount Zion, once a Baptist Church in Athens. Now it has turned into a landmark of preservation, as a soon-to-be cultural center and economic hub for the Black community in Athens.
Jesse Jarrold-Grapes | Photo Editor
The previously named Mt. Zion Baptist Church stands on N Congress St on Wednesday, Oct. 13, 2021.
The group working to turn it into these things is The Mount Zion Baptist Church Preservation Society. It was launched as a non-profit in 2013, and it formed a board to help direct the mission and vision of renovating and restoring the historical monument.
After falling apart for many years due to disrepair, Mount Zion is not in facilitative use, but work toward its renovation is underway. Mount Zion was a staple gathering place for many Black families in and around the Athens area.
“Because the Black population has dwindled to a very low number, we didn’t think restoring it to the original church is (what Athens County needed),” Ada Woodson-Adams, president of The Mount Zion Baptist Church Preservation Society, said. “We thought what Athens and Athens County in the Appalachian area needed was a Black cultural space to showcase the history of the people who came to this area, and who thrived for a long time in this area. This is what we're trying to do at this point.”
The people involved in The Mount Zion Baptist Church Preservation Society have been working for years to preserve the church’s legacy. The group has worked intently on a number of projects to restore the church to its full potential as a gathering place and historical center.
Woodson-Adams was born and raised in Nelsonville, and she was baptized and married in Mount Zion, solidifying her everlasting connection to the church.
“Mount Zion, historically speaking, has been the center of the Black cultural experiences of people who lived in this area,” Woodson-Adams said.
Athens was a safe place for people to live and thrive in the early 1800s, Woodson-Adams said, and it was a place for opportunities. But as time went on and the population began to grow, job opportunities began to diminish for Black people in the region, and many families moved away with no intention of coming back.
“My late husband and I are a rarity, that we wanted to come back and live in an area that had rejected us,” Woodson-Adams said. “Not only did we come back, but we wanted to come back and give back to the community. That's what we did, and that's what I'm still doing.”
“Not only did we come back, but we wanted to come back and give back to the community. That's what we did, and that's what I'm still doing.”—Ada Woodson-Adams
Oftentimes, people are drawn to interact and engage socially with people that look like themselves, Woodson-Adams said. This was and still is difficult for Black people in Athens today.
Woodson-Adams said in the past OU did not encourage the retention of Black professionals, leading to a lack of them in the Athens area. She said many people who have worked with Mount Zion in the past have now moved away for other opportunities, and if retention was the way it should be, this would not be a problem.
Elizabeth Williams, board member of the Mount Zion Baptist Church Preservation Society, like Woodson-Adams, said Mount Zion was a close and committed space for Black people in and around Athens. She believes OU has provided greater support for it in recent years than in years past.
“Now, I believe they are very active in preserving,” Williams said. “They live and learn.”
Butcher said he’s had not only students but also professors visit his museum and leave with a wealth of new knowledge under their belt.
“There were professors that would come here and spent their whole careers not knowing,” Butcher said. “The academia world, let's just say, can be very complicated and difficult, but I'm glad to see that changing. Now I'm affiliated with all kinds of professors who want to bring students down, send students down ... We've gotten a lot of help. That helps us preserve our story.”
Trevellya Ford-Ahmed, the communications and media director for the Mount Zion Baptist Church Preservation Society, believes the support from OU has increased tremendously, but still believes there are lessons that need to be remembered and taught.
Ford-Ahmed believes there are many topics of historical importance, one being the destruction of the nationally renowned Berry Hotel in 1974. The Berry Hotel was owned and run by Edward and Martha “Mattie” Berry, who ran it during a time when Athens was hostile toward Black people. It became a renowned place in Athens and beyond for its top-notch services and memorable architecture. It was innovative for its time, Ford-Ahmed said.
Today there is a need to educate about history of this sort, which Ford-Ahmed, along with the other members of the preservation society, plans to make happen through projects like Mount Zion’s renovation.
With a grant from the Central Appalachian Network Fund, Ford-Ahmed was able to pitch an idea for a film, with a working title of “Black Wall Street Athens County.” This film is now a reality and will take an in-depth look at Black-owned businesses, schools and more that have been destroyed in Athens County over the years. The Berry Hotel is only one of these examples.
Ford-Ahmed has high hopes for the project.
Currently employed at OU, Lisa Flowers-Clements, assistant director for academic support and advising in the Office of Multicultural Success and Retention, grew up in Washington County. She has thought a lot about Appalachia and how it is viewed today by those in the region and those coming into the region for education.
Jesse Jarrold-Grapes | Photo Editor
David Butcher explains his lineage as the one of the descendants of Hannah Tabler on Tuesday, Oct. 12, 2021 at one of the sites of the historical collection he has currated to tell the story of his family and the known Black history of the Athens area.
Flowers-Clements feels today the historical and current connection to Black people in Appalachia is not acknowledged by many in the Athens area. However, she thinks there are intentional actions behind the exclusion of people of color in this dialogue.
“I'm not sure that it's forgotten accidentally. I think it was intentionally not included in a lot of ways,” Flowers-Clements said. “Even if we look at when someone says ‘Appalachian’ – what automatically comes to mind? It's typically not someone of color.”
Alongside the underrepresentation of Black people in Appalachia, Flowers-Clements believes there are aspects of OU history that students are not taught that are necessary for understanding where they go to school.
“I would say it's all of our responsibility to make sure that the history remains alive and well,” Flowers-Clements said. “And that includes me, so now I'm thinking ‘Okay am I doing enough to make sure that this history is preserved.’ And then not just preserved but told … We also need to tell that history and speak about it and make sure that it is acknowledged when we talk about the rich history of Appalachia – that we're including all of that rich history and not just a subsection of the history.”
As for university connections, Mount Zion has been able to collaborate with many students, feeling a sense of support from those who are eager to help whenever it’s needed.
“There's been an awakening of information,” Williams said. “We have so much collaboration and support from the students and administration of OU at this period of time. We can always use more, but they're very generous with their efforts … Every time we put a call out for student involvement or something, there seems to be someone that pops up and helps us out.”
Within OU, Black students from the region are able to find support among different student organizations and more. Winsome Chunnu-Brayda, director of OU’s Multicultural Center, said OU has worked hard to make sure there are spaces for Black students, including around 30 student organizations.
“I think it's crucial to keep this history alive for all the groups that are at OU,” Chunnu-Brayda said. “It's a part of the university's history. It shows those students from those communities can learn as well as every other Bobcat can.
Within Athens, there are businesses who contribute to Mount Zion in hopes of helping the preservation of the history crucial to understanding the region.
Jesse Jarrold-Grapes | Photo Editor
A plaque on Mulberry Street pays respects and marks the spot an Athens mob lynched Christopher Davis, 24, in 1881.
Riley Kinnard, the general manager at Kindred Market, said donating to places such as Mount Zion is important in cultivating relationships and connections with places making an impact on Athens. Kinnard said it was important to the business to pick organizations supporting racial equality.
Support from small businesses and other organizations in the region are an important aspect of the preservation of Black history; however, Ford-Ahmed believes the same amount of support needs to be given to Black businesses as well.
“Black entrepreneurship, buildings, business, etc., has not been given, I think, the credit or the recognition, just as so much Black history has not,” Ford-Ahmed said.
Ford-Ahmed believes it’s important for there to not only be support for the remembrance of this history but also to support and lift up Black people in the region today.
OU is a new territory for many students, and many students don’t know the history behind their new home, but with the help of the Mount Zion Baptist Church Preservation Society, Butcher, student organizations, local businesses and more, people are able to not only learn about but also help with the preservation of Black Appalachian culture and history in Athens.
“Building our future by preserving our past, that’s why we do what we do,”—Trevellya Ford-Ahmed


On the Define role-specific prices page, you can specify charges for service roles that are specified in the technical service definition. Service roles can be used to grant specific privileges to different users. They can be mapped to corresponding permissions in the underlying application.
For each service role, you can define a price. This price is added to the base price per user in the cost calculation for a billing period.
To define prices for service roles:


Free Evaluation Guide for Architects & IT Leaders
If you're an Architect, Senior Developer, or Executive charged with identifying the right application development solution for your business, this guide is for you. It’s meant to answer the top questions that enterprise teams are likely to have when evaluating Ionic for a critical development project.
In this guide, you’ll learn:
- When & why to choose Ionic
- Which use cases are best, including customer examples
- How the technology works
- How Ionic’s products and services can help you boost development
- What makes Ionic unique compared to React Native and others


The central concepts of D-Bus are modelled in a very similar way in dbus-glib and GDBus. Both have a objects representing connections, proxies and method invocations. But there are some important differences:
dbus-glib uses the libdbus reference implementation, GDBus doesn't. Instead, it relies on GIO streams as transport layer, and has its own implementation for the the D-Bus connection setup and authentication. Apart from using streams as transport, avoiding libdbus also lets GDBus avoid some thorny multithreading issues.
dbus-glib uses the GObject type system for method arguments and return values, including a homegrown container specialization mechanism. GDBus relies on the GVariant type system which is explicitly designed to match D-Bus types.
dbus-glib models only D-Bus interfaces and does not provide any types for objects. GDBus models both D-Bus interfaces (via the GDBusInterface, GDBusProxy and GDBusInterfaceSkeleton types) and objects (via the GDBusObject, GDBusObjectSkeleton and GDBusObjectProxy types).
GDBus includes native support for the org.freedesktop.DBus.Properties (via the GDBusProxy type) and org.freedesktop.DBus.ObjectManager D-Bus interfaces, dbus-glib doesn't.
The typical way to export an object in dbus-glib involves generating glue code from XML introspection data using dbus-binding-tool. GDBus provides a similar tool called gdbus-codegen that can also generate Docbook D-Bus interface documentation.
dbus-glib doesn't provide any convenience API for owning and
watching bus names, GDBus provides the g_bus_own_name()
and
g_bus_watch_name()
family of convenience functions.
GDBus provides API to parse, generate and work with Introspection XML, dbus-glib doesn't.
GTestDBus provides API to create isolated unit tests GDBus Test Scaffolding.


(Attention: These are the class notes for the Lambda School pre-course instruction workshop. This is meant to serve as an accompaniment to the class)
In this lesson we will cover:
A very important concept in Javascript is the ability to pass a function
as an arguments to another function. These functions are called
callbacks
. These functions can be called anytime and passed
arguments within the function. We will soon discover why callbacks are so
important to Javascript. Convention is to use the cb
argument
variable as your callback.
function saysHelloToUser(user) {
return "Hello " + user + "!";
}
function saysGoodbyeToUser(user) {
return "Goodbye " + user + "!";
}
function createGreeting(user, cb) {
return cb(user);
}
createGreeting("Dan", saysHelloToUser); // 'Hello Dan!'
createGreeting("Dan", saysGoodbyeToUser); // 'Goodbye Dan!'
We already know about and use array methods, .push
,
.pop
, .shift
, .unshift
, and
.length
. But there are a lot more methods available to us
natively on an array. The methods we are going to talk about here are
called higher order methods, because they take callbacks as arguments.
.forEach
is a built in for loop on every array.
.forEach
takes a callback as its only argument, and iterates
over every item in the array and calls the callback on it. The callback
can take two arguments, the first is the item itself, the second is the
index of the item, this argument is optional.
const cars = ["Ford", "Chevrolet", "Toyota", "Tesla"];
// We can write the callback function itself in the parentheses as an anonymous function
cars.forEach(function (item, index) {
console.log(item);
});
// Or we can instantiate a function to be used as a callback.
// Also, we do not need to use the index argument, if you don’t need it, feel free to leave it out.
function printNames(item) {
console.log(item);
}
// And call that function in the forEach parentheses
cars.forEach(printNames);
.reduce
will run a loop on our array with the intention of
reducing each item into one item that is returned. As it’s first argument
it takes a callback that takes two arguments, first an ‘accumulator’ (the
result of the reduce method until now), and the second is the item it is
currently on. The callback must ALWAYS contain a return statement. Reduce
also takes an optional second argument, which would be the starting
accumulator. If the starting accumulator is not supplied reduce will start
at the first item of the array. .reduce
will always return
the accumulator when it is done iterating through the items.
const nums = [1, 2, 3, 4, 5, 6, 7, 8, 9];
const words = ["Hi,", "my", "name", "is", "Dan"];
// We can write the anonymous function directly into the .reduce parentheses
// If we leave out the starting item, it will always start at the first item.
const sums = nums.reduce(function (acc, item) {
return acc + item;
});
// We can write a function outside of the .reduce parens (to be used multiple times later)
function multiplyTwoNumbers(a, b) {
return a * b;
}
const products = nums.reduce(multiplyTwoNumbers);
// .reduce works on any data types.
// In this example we set a starting accumulator
const sentence = words.reduce(function (acc, item) {
return acc + " " + item;
}, "Sentence:");
console.log(sums); // 45
console.log(products); // 362880
console.log(sentence); // 'Sentence: Hi, my name is Dan'
.map
is used when we want to change every item in an array in
the same way. .map
takes a callback as its only argument.
Like the .forEach
method, the callback has the optional
arguments item and index. Unlike .reduce
,
.map
will return the entire array.
const nums = [2, 3, 4, 5];
function multiplyByThree(item) {
return item * 3;
}
const double = nums.map(function (item) {
return item * 2;
});
const triple = nums.map(multiplyByThree);
console.log(double); // [ 4, 6, 8, 10 ]
console.log(triple); // [ 6, 9, 12, 15 ]


From Computer Desktop Encyclopedia
Reproduced with permission.
®2004 National Center for Supercomputer Aplications


Bubble Magnet Controller
So, I was looking for inspiration for something to do that is interactive on my portfolio and came across this. I really enjoyed it, and saw it used Canvas which I feel a little weak on, so I re-created it to get some canvas experience. I also added a few options to make it a little bit better as it also allowed me to better understand everything that was happening.
I ultimately decided not to use it in my portfolio, but I had already converted it to a JS file that can easily be imported into a project for use, so I thought why not post it. In accordance with CodePen license, this follows the same MIT License policy of being open sourced.
View the JS here: Link
Simply put this in your head or at the end of your html file : <script src="bubbleCanvas.js"></script>
and move the JS file to your project. This also requires jQuery so make sure the file is included.
Start the script by calling startBubbling('body', true);
Replace body with the class or id call, i.e. '.center-box' or '#middle', quotation is required
If you dont want the controls to appear, replace true with false. Edit the css of the controls using class magnetControls. Edit the JS file under the function startBubbling to alter any of the controls.
Click on any of the below bordered areas to start bubbling inside.
Click again to attract or push the bubbles away.
Automatically fits any size and shape div
Simply reshape using CSS. The application applies a rectangular canvas, so in shaped divs, some of the canvas will be cut off.
Or you can have it fill the screen by keeping body and adding the following CSS rule :
canvas {
background: [add your color option];
display: block;
left: 0;
position: absolute;
top: 0;
}
Or make a div height: 100vh; width: 100%;
And it reshapes automatically too


How long between starting clusters
Number of clusters
Extended eris client class (should extend Eris.Client)
Whether to use faster start
How long to wait before giving up on a fetch
First shard ID to use on this instance of eris-fleet
Guilds per shard
Amount of time to wait before doing a forced shutdown during shutdowns
Last shard ID to use on this instance of eris-fleet
Option to have less logging show up
Node arguments to pass to the clusters
Whether to split the source in to an Object
Absolute path to the js file
How long to wait for a service to connect
Services to start by name and path
Number of shards
Custom starting status
How often to update the stats after all clusters are spawned (set to "disable" to disable automated stats)
How long to wait for shards to connect to discord
Bot token
Allows for more logging customization (overrides generic lessLogging option)
Blacklist of what to log
Whitelist of what to log
Generated using TypeDoc
Options to pass to the Eris client constructor


|
solver
|
Class that contains all information about the optimization variables such as upper and lower bounds, initial guess if any, and some auxiliary functions for easier handling. More...
#include <OptVar.hpp>
Public Member Functions | |
| OptimizationVariable () | |
| Class constructor and destructor. | |
| void | initialize (const char &type, int rows, int cols, double lBnd, double uBnd, int &startIndexInOptVec) |
| Some alternative initialization functions. | |
| void | initialize (const char &type, int rows, int cols, OptVector &lBnd, OptVector &uBnd, int &startIndexInOptVec) |
| void | initialize (const char &type, int rows, int cols, OptMatrix &lBnd, OptMatrix &uBnd, int &startIndexInOptVec) |
| void | initialize (const char &type, int rows, int cols, double lBnd, double uBnd, int &startIndexInOptVec, double guess) |
| void | initialize (const char &type, int rows, int cols, double lBnd, double uBnd, int &startIndexInOptVec, OptMatrix &guess) |
| void | initialize (const char &type, int rows, int cols, OptVector &lBnd, OptVector &uBnd, int &startIndexInOptVec, OptMatrix &guess) |
| void | initialize (const char &type, int rows, int cols, OptMatrix &lBnd, OptMatrix &uBnd, int &startIndexInOptVec, OptMatrix &guess) |
| int | id (int row, int col) const |
| Some helper functions to construct the problem. | |
| void | constraintIndexToCurrentValue (int index) |
| void | setAndConstraintIndexToCurrentValue (int index, double value) |
| void | setAndConstraintIndexToCurrentValue (int index, OptVector &value) |
| void | getValues (OptMatrix &lBnd, OptMatrix &uBnd, OptMatrix &guess, int &size, char &type) const |
| int | getNumRows () const |
| Some getter and setter methods. | |
| int | getNumCols () const |
| int | getStartIndex () const |
| int | getNumElements () const |
| void | getGuessValue (OptMatrix &guess) const |
| void | getGuessValueByCol (int index, OptVector &guess) const |
| void | setGuessValue (const OptMatrix &guess) |
Private Member Functions | |
| int | getRowBndInd (int row) const |
| Some helper functions to construct the problem. | |
| int | getColBndInd (int col) const |
| int | getBlockLen (int rini, int cini, int rend, int cend) const |
Private Attributes | |
| char | type_ |
| bool | guessValueInitialized_ |
| int | indexPosition_ |
| int | rows_ |
| int | cols_ |
| OptMatrix | lBndMat_ |
| OptMatrix | uBndMat_ |
| OptMatrix | guessMat_ |
Class that contains all information about the optimization variables such as upper and lower bounds, initial guess if any, and some auxiliary functions for easier handling.


Anatomy of an epidemic: How measles took hold of Samoa
by Melissa ClarkeSixty-three children in Samoa have died from measles. After a mass vaccination campaign, authorities are hopeful the spread of the highly contagious virus has been contained, but remain on edge. How did it come to this?
The family of 10-year-old Fa'auuga Iosefa crowd around his grave.
As his body is lowered, Fa'auuga's older brother wails in grief.
His sisters clutch photographs of him, then clutch each other for support.
The little boy's final resting place will be in the front yard of the family home.
It's the traditional place to keep ancestors close — except he's the wrong generation, dying far too young.
But this way, he will never be far from his mother.
Alieta Iosefa weeps.
  Having to bury him is a void."
"He survived cancer but caught [measles] from hospital. His immunity was low and his heart was very tiny. He tried to fight, but the more he fought, the more damage it did."
Fa'auuga is one of 70 people who have been killed by measles in Samoa since October, and all but seven were aged under 15. Nearly 4,700 other Samoans have been infected.
Samoa's measles epidemic grew slowly, then swelled suddenly.
A few cases appeared in October. By November, the Samoan Government had declared a state of emergency. Schools were closed and vaccinations made mandatory.
But it was not enough to halt the spread of the virus.
Measles infections had popped up around the Pacific, but the virus only took hold in Samoa, where the national immunisation rate had fallen to a low of 30 per cent.
A preventable crisis
The troublesomely low immunisation rate was borne of an earlier tragedy.
In 2018, two babies died shortly after getting measles vaccinations. The nurses who administered the injections had incorrectly mixed an expired anaesthetic with the vaccine.
It prompted the Government to suspend the nation's vaccination program and though it was eventually restored, many Samoan mothers no longer trusted the vaccination process.
The Samoan Government took the drastic step of arranging a nation-wide shutdown to get people vaccinated.
Businesses were ordered to close and all citizens placed under a curfew to allow mobile vaccination teams to go door-to-door.
Residents were told to hang a red flag outside their house to indicate there was someone inside who needed vaccination.
Everything from crimson leis to the red-and-blue Samoan flag to were put to use.
Over the two days, around 120 medical teams traversed the roads of Samoa in vehicles commandeered from across government agencies and NGOs.
Fast and efficient, the teams vaccinated approximately 40,000 people, around 20 per cent of Samoa's entire population.
Most of those getting a jab were welcoming, enthusiastic to contribute to a project akin to a national reparation.
"It hurts, it hurts," said Iani Sheppard, wincing and laughing all at once.
"Good to have it done, it's a relief to have it done. Likewise, everyone else … it's a must for everyone.
"Most people don't have the transport … so this is very good, a good initiative for the Government to do, to come visit door to door and have this done.
"I pray that everyone will have this injection done so that this can be eliminated, this virus, from us."
But not everyone heeded the call.
'There was no trust'
Some of the nurses reported seeing people run away as mobile vaccination teams neared.
Others stayed but refused to be treated. Some parents turned to traditional healers first, only seeking help from the medical system when it was too late.
After the two deaths last year from incorrectly administered vaccines, there has been a new audience for anti-vaccination campaigners.
Both local and foreign 'anti-vaxxers' peddled their messages on social media, a potent act in a country where Facebook is a key source of information.
It has prompted heated debate amongst Samoans about who is to blame for the scale of the measles crisis — parents who did not vaccinate their children, or the Government for not addressing their mistrust in the system sooner?
Samoa's Prime Minister Tuilaepa Sailele is blunt.
"Parents should bring their children for vaccination," he said.
But he rejects suggestions that such remarks put the blame on parents.
"There are parents who did not believe that their children should be vaccinated … it is a question of educating our people to understand what they must do," he said.
"It is imperative … to strengthen the culture of acceptance of vaccination in order to create herd immunity.
"This is a painful lesson we have learnt from the current crisis."
The United Nations' resident coordinator in Samoa, Simona Marinescu, had a similar take.
"The system was in place and capable of providing vaccination, it's just that mothers did not want to come," she said.
"It is very difficult to convince mothers to come back to get their babies vaccinated, seeing what happened to the two families last year.
"There was no trust."
In 2018, measles caused close to 142,000 deaths around the world and the United Nations' sees in Samoa's epidemic echoes of global problems.
"Scepticism regarding the safety of the vaccine and the expanding atmosphere of doubt around vaccination — even in the most advanced countries — are among the underlying causes of the dramatic expansion of the disease," said Ms Marinescu.
Church on Sunday
Churches are the central pillar of community life in Samoa, a deeply religious nation.
Services have been cut and children discouraged from attending in an effort to limit the spread of measles in community gatherings.
But Sunday mass remains a source of solace for Samoans at a time when there seems little to be grateful for.
Lina Chang from the Samoa Victim Support Group has found the families of children suffering with measles struggling to remain positive.
"It's too early to say something about it because there's still suffering," she said.
"For our vulnerable families now, this is the only resort, turning to God."


Spec
Top Down History IteratorString tree iterator that can go down, right, and up. Supports depth-
first search.
String tree iterator that can go down, right, and up. Supports depth-
first search.
| Extends | TopDownIterator |
|---|---|
| Implements | ForwardIteratorConcept |
| All Extended | Iter, TopDownIterator, VSTreeIterator |
| All Impl'd | CopyConstructibleConcept, DefaultConstructibleConcept, EqualityComparableConcept, ForwardIteratorConcept, InputIteratorConcept, IteratorAssociatedTypesConcept |
| Defined in | <seqan/index.h> |
| Signature |
template <typename TIndex, typename TSpec>
class Iter<TIndex, VSTree<TopDown<ParentLinks<TSpec> > > >;
|
Template Parameters
TSpec |
Specifies the depth-first search mode. Types: DfsOrder |
|---|---|
TIndex |
Type of the container that can be iterated. Types: IndexDfi, IndexEsa, IndexWotd, FMIndex, IndexSa |
Member Function Overview
-
Iter::Iter(index);, Iter::Iter(iterator);
Constructor
Member Functions Inherited From Iter
Member Functions Inherited From TopDownIterator
Member Functions Inherited From EqualityComparableConcept
Interface Function Overview
-
bool goUp(iterator);
Iterates up one edge to the parent in a tree/trie. -
bool lca(a, b, result);
Returns the last common ancestor of two tree nodes. -
TSize lcp(a, b);
Returns the length of the longest-common-prefix of two suffix tree nodes. -
TSize nodeDepth(iterator);
Returns the zero-based node depth of the iterator node.
Interface Functions Inherited From TopDownIterator
emptyParentEdge
goDown
goRight
nodeUp
parentEdgeFirstChar
parentEdgeLabel
parentEdgeLength
parentRepLength
Interface Functions Inherited From VSTreeIterator
alignment
assignProperty
atEnd
childrenAreLeaves
countChildren
countOccurrences
getFrequency
getOccurrence
getOccurrences
getOccurrencesBwt
getProperty
goBegin
goNext
goRoot
isLeaf
isLeftMaximal
isPartiallyLeftExtensible
isRightTerminal
isRoot
isUnique
nodeHullPredicate
nodePredicate
property
range
repLength
representative
value
Interface Functions Inherited From InputIteratorConcept
Interface Functions Inherited From IteratorAssociatedTypesConcept
Interface Metafunction Overview
Interface Metafunctions Inherited From Iter
Interface Metafunctions Inherited From VSTreeIterator
Interface Metafunctions Inherited From IteratorAssociatedTypesConcept
Detailed Description
Note:
Instead of using the class Iter directly we recommend to use the result of the metafunction Iterator<TContainer, TopDown<ParentLinks<TSpec> > >::Type (which is Iter<TContainer, VSTree<ParentLinks<TopDown<TSpec> > > >).
If not copy-constructed the TopDownHistoryIterator starts in the root node of the string tree. Depending on the depth-first search mode the root is not the first DFS node. To go to the first DFS node use goBegin.
Example
Member Functions Detail
Iter::Iter(index);
Iter::Iter(iterator);
Constructor
Parameters
index
|
An index object. |
|---|---|
iterator
|
Another TopDownHistory iterator. (copy constructor) Types: TopDownHistory Iterator |
If not copy-constructed the TopDownHistoryIterator starts in the root node of the string tree.
Data Races
Thread safety unknown!
Interface Functions Detail
bool goUp(iterator);
Iterates up one edge to the parent in a tree/trie.
Parameters
iterator
|
An iterator of a string tree/trie. |
|---|
Returns
bool |
true if the iterator could be moved, otherwise false. |
|---|
Example
The following code shows how the function goUp is used.
#include <seqan/index.h> using namespace seqan; int main() { typedef Index<CharString> TIndex; TIndex index("tobeornottobe"); Iterator<TIndex, TopDown<ParentLinks<> > >::Type it(index); do { // Print the letters from the root to the current node std::cout << representative(it) << std::endl; if (!goDown(it) && !goRight(it)) while (goUp(it) && !goRight(it)) ; } while (!isRoot(it)); return 0; }
be beornottobe e eornottobe nottobe o obe obeornottobe ornottobe ottobe rnottobe t tobe tobeornottobe ttobe
Data Races
Thread safety unknown!
bool lca(a, b, result);
Returns the last common ancestor of two tree nodes.
Parameters
a
|
The first node. Types: TopDownHistoryIterator |
|---|---|
b
|
The second node. Types: TopDownHistoryIterator |
result
|
A reference to the resulting lca node. Types: TopDownHistoryIterator |
Returns
TReturn |
false if the lca of a and b is the root node, otherwise true. |
|---|
Data Races
Thread safety unknown!
TSize lcp(a, b);
Returns the length of the longest-common-prefix of two suffix tree
nodes.
Parameters
a
|
The first node. Types: TopDownHistoryIterator |
|---|---|
b
|
The second node. Types: TopDownHistoryIterator |
Returns
TSize |
The lcp-length of a and b. The type of the result is the result of the metafunction Size of the Index of the iterator |
|---|
Data Races
Thread safety unknown!
TSize nodeDepth(iterator);
Returns the zero-based node depth of the iterator node.
Parameters
iterator
|
An iterator of a string tree. |
|---|
Returns
TSize |
The length of the path from root to iterator node, e.g. 0 is returned for the root node. The type of the result is the result of the metafunction Size of the underlying index. |
|---|
Data Races
Thread safety unknown!


Project: Camera Phone
View Latest
View Oldest
Project Info
Phone Info
Download
Other Projects
AngryNoodle


@(playerForm: Form[(String, String)])(implicit request: RequestHeader, messagesProvider: MessagesProvider)
@import helper._
@main(title = "Tennis Game") {
Choose Players For Tennis Game:
@form(action = routes.GameController.play, args = Symbol("id") -> "playerForm") {
@inputText(
field = playerForm("player1"),
args = Symbol("_label") -> "Player 1 name", Symbol("placeholder") -> "Player 1"
)
@inputText(
field = playerForm("player2"),
args = Symbol("_label") -> "Player 2 name", Symbol("placeholder") -> "Player 2"
)
}
}


| 1 | /* | |
| 2 | * Licensed to the Apache Software Foundation (ASF) under one or more | |
| 3 | * contributor license agreements. See the NOTICE file distributed with | |
| 4 | * this work for additional information regarding copyright ownership. | |
| 5 | * The ASF licenses this file to You under the Apache License, Version 2.0 | |
| 6 | * (the "License"); you may not use this file except in compliance with | |
| 7 | * the License. You may obtain a copy of the License at | |
| 8 | * | |
| 9 | * http://www.apache.org/licenses/LICENSE-2.0 | |
| 10 | * | |
| 11 | * Unless required by applicable law or agreed to in writing, software | |
| 12 | * distributed under the License is distributed on an "AS IS" BASIS, | |
| 13 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| 14 | * See the License for the specific language governing permissions and | |
| 15 | * limitations under the License. | |
| 16 | */ | |
| 17 | package org.apache.commons.collections4; | |
| 18 | ||
| 19 | import java.util.AbstractList; | |
| 20 | import java.util.ArrayList; | |
| 21 | import java.util.Collection; | |
| 22 | import java.util.Collections; | |
| 23 | import java.util.HashSet; | |
| 24 | import java.util.Iterator; | |
| 25 | import java.util.List; | |
| 26 | ||
| 27 | import org.apache.commons.collections4.bag.HashBag; | |
| 28 | import org.apache.commons.collections4.functors.DefaultEquator; | |
| 29 | import org.apache.commons.collections4.list.FixedSizeList; | |
| 30 | import org.apache.commons.collections4.list.LazyList; | |
| 31 | import org.apache.commons.collections4.list.PredicatedList; | |
| 32 | import org.apache.commons.collections4.list.TransformedList; | |
| 33 | import org.apache.commons.collections4.list.UnmodifiableList; | |
| 34 | import org.apache.commons.collections4.sequence.CommandVisitor; | |
| 35 | import org.apache.commons.collections4.sequence.EditScript; | |
| 36 | import org.apache.commons.collections4.sequence.SequencesComparator; | |
| 37 | ||
| 38 | /** | |
| 39 | * Provides utility methods and decorators for {@link List} instances. | |
| 40 | * | |
| 41 | * @since 1.0 | |
| 42 | * @version $Id: ListUtils.java 1540567 2013-11-10 22:19:29Z tn $ | |
| 43 | */ | |
| 44 | public class ListUtils { | |
| 45 | ||
| 46 | /** | |
| 47 | * ListUtils should not normally be instantiated. | |
| 48 | */ | |
| 49 | private ListUtils() {} | |
| 50 | ||
| 51 | //----------------------------------------------------------------------- | |
| 52 | ||
| 53 | /** | |
| 54 | * Returns an immutable empty list if the argument is null, | |
| 55 | * or the argument itself otherwise. | |
| 56 | * | |
| 57 | * @param <T> the element type | |
| 58 | * @param list the list, possibly null | |
| 59 | * @return an empty list if the argument is null | |
| 60 | */ | |
| 61 | public static <T> List<T> emptyIfNull(final List<T> list) { | |
| 62 |
2
1. emptyIfNull : negated conditional → NO_COVERAGE 2. emptyIfNull : mutated return of Object value for org/apache/commons/collections4/ListUtils::emptyIfNull to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return list == null ? Collections.<T>emptyList() : list; |
| 63 | } | |
| 64 | ||
| 65 | /** | |
| 66 | * Returns either the passed in list, or if the list is {@code null}, | |
| 67 | * the value of {@code defaultList}. | |
| 68 | * | |
| 69 | * @param <T> the element type | |
| 70 | * @param list the list, possibly {@code null} | |
| 71 | * @param defaultList the returned values if list is {@code null} | |
| 72 | * @return an empty list if the argument is null | |
| 73 | * @since 4.0 | |
| 74 | */ | |
| 75 | public static <T> List<T> defaultIfNull(final List<T> list, final List<T> defaultList) { | |
| 76 |
2
1. defaultIfNull : negated conditional → NO_COVERAGE 2. defaultIfNull : mutated return of Object value for org/apache/commons/collections4/ListUtils::defaultIfNull to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return list == null ? defaultList : list; |
| 77 | } | |
| 78 | ||
| 79 | /** | |
| 80 | * Returns a new list containing all elements that are contained in | |
| 81 | * both given lists. | |
| 82 | * | |
| 83 | * @param <E> the element type | |
| 84 | * @param list1 the first list | |
| 85 | * @param list2 the second list | |
| 86 | * @return the intersection of those two lists | |
| 87 | * @throws NullPointerException if either list is null | |
| 88 | */ | |
| 89 | public static <E> List<E> intersection(final List<? extends E> list1, final List<? extends E> list2) { | |
| 90 | final List<E> result = new ArrayList<E>(); | |
| 91 | ||
| 92 | List<? extends E> smaller = list1; | |
| 93 | List<? extends E> larger = list2; | |
| 94 |
2
1. intersection : changed conditional boundary → NO_COVERAGE 2. intersection : negated conditional → NO_COVERAGE |
if (list1.size() > list2.size()) { |
| 95 | smaller = list2; | |
| 96 | larger = list1; | |
| 97 | } | |
| 98 | ||
| 99 | final HashSet<E> hashSet = new HashSet<E>(smaller); | |
| 100 | ||
| 101 |
1
1. intersection : negated conditional → NO_COVERAGE |
for (final E e : larger) { |
| 102 |
1
1. intersection : negated conditional → NO_COVERAGE |
if (hashSet.contains(e)) { |
| 103 | result.add(e); | |
| 104 | hashSet.remove(e); | |
| 105 | } | |
| 106 | } | |
| 107 |
1
1. intersection : mutated return of Object value for org/apache/commons/collections4/ListUtils::intersection to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return result; |
| 108 | } | |
| 109 | ||
| 110 | /** | |
| 111 | * Subtracts all elements in the second list from the first list, | |
| 112 | * placing the results in a new list. | |
| 113 | *
 | |
| 114 | * This differs from {@link List#removeAll(Collection)} in that | |
| 115 | * cardinality is respected; if list1 contains two | |
| 116 | * occurrences of null and list2 only | |
| 117 | * contains one occurrence, then the returned list will still contain | |
| 118 | * one occurrence. | |
| 119 | * | |
| 120 | * @param <E> the element type | |
| 121 | * @param list1 the list to subtract from | |
| 122 | * @param list2 the list to subtract | |
| 123 | * @return a new list containing the results | |
| 124 | * @throws NullPointerException if either list is null | |
| 125 | */ | |
| 126 | public static <E> List<E> subtract(final List<E> list1, final List<? extends E> list2) { | |
| 127 | final ArrayList<E> result = new ArrayList<E>(); | |
| 128 | final HashBag<E> bag = new HashBag<E>(list2); | |
| 129 |
1
1. subtract : negated conditional → NO_COVERAGE |
for (final E e : list1) { |
| 130 |
1
1. subtract : negated conditional → NO_COVERAGE |
if (!bag.remove(e, 1)) { |
| 131 | result.add(e); | |
| 132 | } | |
| 133 | } | |
| 134 |
1
1. subtract : mutated return of Object value for org/apache/commons/collections4/ListUtils::subtract to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return result; |
| 135 | } | |
| 136 | ||
| 137 | /** | |
| 138 | * Returns the sum of the given lists. This is their intersection | |
| 139 | * subtracted from their union. | |
| 140 | * | |
| 141 | * @param <E> the element type | |
| 142 | * @param list1 the first list | |
| 143 | * @param list2 the second list | |
| 144 | * @return a new list containing the sum of those lists | |
| 145 | * @throws NullPointerException if either list is null | |
| 146 | */ | |
| 147 | public static <E> List<E> sum(final List<? extends E> list1, final List<? extends E> list2) { | |
| 148 |
1
1. sum : mutated return of Object value for org/apache/commons/collections4/ListUtils::sum to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return subtract(union(list1, list2), intersection(list1, list2)); |
| 149 | } | |
| 150 | ||
| 151 | /** | |
| 152 | * Returns a new list containing the second list appended to the | |
| 153 | * first list. The {@link List#addAll(Collection)} operation is | |
| 154 | * used to append the two given lists into a new list. | |
| 155 | * | |
| 156 | * @param <E> the element type | |
| 157 | * @param list1 the first list | |
| 158 | * @param list2 the second list | |
| 159 | * @return a new list containing the union of those lists | |
| 160 | * @throws NullPointerException if either list is null | |
| 161 | */ | |
| 162 | public static <E> List<E> union(final List<? extends E> list1, final List<? extends E> list2) { | |
| 163 | final ArrayList<E> result = new ArrayList<E>(list1); | |
| 164 | result.addAll(list2); | |
| 165 |
1
1. union : mutated return of Object value for org/apache/commons/collections4/ListUtils::union to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return result; |
| 166 | } | |
| 167 | ||
| 168 | /** | |
| 169 | * Selects all elements from input collection which match the given | |
| 170 | * predicate into an output list. | |
| 171 | *
 | |
| 172 | * A null predicate matches no elements. | |
| 173 | * | |
| 174 | * @param <E> the element type | |
| 175 | * @param inputCollection | |
| 176 | * the collection to get the input from, may not be null | |
| 177 | * @param predicate | |
| 178 | * the predicate to use, may be null | |
| 179 | * @return the elements matching the predicate (new list) | |
| 180 | * @throws NullPointerException | |
| 181 | * if the input list is null | |
| 182 | * | |
| 183 | * @since 4.0 | |
| 184 | * @see CollectionUtils#select(Iterable, Predicate) | |
| 185 | */ | |
| 186 | public static <E> List<E> select(final Collection<? extends E> inputCollection, | |
| 187 | final Predicate<? super E> predicate) { | |
| 188 |
1
1. select : mutated return of Object value for org/apache/commons/collections4/ListUtils::select to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return CollectionUtils.select(inputCollection, predicate, new ArrayList<E>(inputCollection.size())); |
| 189 | } | |
| 190 | ||
| 191 | /** | |
| 192 | * Selects all elements from inputCollection which don't match the given | |
| 193 | * predicate into an output collection. | |
| 194 | *
 | |
| 195 | * If the input predicate is null, the result is an empty | |
| 196 | * list. | |
| 197 | * | |
| 198 | * @param <E> the element type | |
| 199 | * @param inputCollection | |
| 200 | * the collection to get the input from, may not be null | |
| 201 | * @param predicate | |
| 202 | * the predicate to use, may be null | |
| 203 | * @return the elements not matching the predicate (new list) | |
| 204 | * @throws NullPointerException | |
| 205 | * if the input collection is null | |
| 206 | * | |
| 207 | * @since 4.0 | |
| 208 | * @see CollectionUtils#selectRejected(Iterable, Predicate) | |
| 209 | */ | |
| 210 | public static <E> List<E> selectRejected(final Collection<? extends E> inputCollection, | |
| 211 | final Predicate<? super E> predicate) { | |
| 212 |
1
1. selectRejected : mutated return of Object value for org/apache/commons/collections4/ListUtils::selectRejected to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return CollectionUtils.selectRejected(inputCollection, predicate, new ArrayList<E>(inputCollection.size())); |
| 213 | } | |
| 214 | ||
| 215 | /** | |
| 216 | * Tests two lists for value-equality as per the equality contract in | |
| 217 | * {@link java.util.List#equals(java.lang.Object)}. | |
| 218 | *
 | |
| 219 | * This method is useful for implementing List when you cannot | |
| 220 | * extend AbstractList. The method takes Collection instances to enable other | |
| 221 | * collection types to use the List implementation algorithm. | |
| 222 | *
 | |
| 223 | * The relevant text (slightly paraphrased as this is a static method) is: | |
| 224 | *
 | |
| 225 | * Compares the two list objects for equality. Returns | |
| 226 | * <tt>true</tt> if and only if both | |
| 227 | * lists have the same size, and all corresponding pairs of elements in | |
| 228 | * the two lists are equal. (Two elements <tt>e1</tt> and | |
| 229 | * <tt>e2</tt> are equal if <tt>(e1==null ? e2==null : | |
| 230 | * e1.equals(e2))</tt>.) In other words, two lists are defined to be | |
| 231 | * equal if they contain the same elements in the same order. This | |
| 232 | * definition ensures that the equals method works properly across | |
| 233 | * different implementations of the <tt>List</tt> interface. | |
| 234 | *
 | |
| 235 | * | |
| 236 | * Note: The behaviour of this method is undefined if the lists are | |
| 237 | * modified during the equals comparison. | |
| 238 | * | |
| 239 | * @see java.util.List | |
| 240 | * @param list1 the first list, may be null | |
| 241 | * @param list2 the second list, may be null | |
| 242 | * @return whether the lists are equal by value comparison | |
| 243 | */ | |
| 244 | public static boolean isEqualList(final Collection<?> list1, final Collection<?> list2) { | |
| 245 |
1
1. isEqualList : negated conditional → NO_COVERAGE |
if (list1 == list2) { |
| 246 |
1
1. isEqualList : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return true; |
| 247 | } | |
| 248 |
3
1. isEqualList : negated conditional → NO_COVERAGE 2. isEqualList : negated conditional → NO_COVERAGE 3. isEqualList : negated conditional → NO_COVERAGE |
if (list1 == null || list2 == null || list1.size() != list2.size()) { |
| 249 |
1
1. isEqualList : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return false; |
| 250 | } | |
| 251 | ||
| 252 | final Iterator<?> it1 = list1.iterator(); | |
| 253 | final Iterator<?> it2 = list2.iterator(); | |
| 254 | Object obj1 = null; | |
| 255 | Object obj2 = null; | |
| 256 | ||
| 257 |
2
1. isEqualList : negated conditional → NO_COVERAGE 2. isEqualList : negated conditional → NO_COVERAGE |
while (it1.hasNext() && it2.hasNext()) { |
| 258 | obj1 = it1.next(); | |
| 259 | obj2 = it2.next(); | |
| 260 | ||
| 261 |
3
1. isEqualList : negated conditional → NO_COVERAGE 2. isEqualList : negated conditional → NO_COVERAGE 3. isEqualList : negated conditional → NO_COVERAGE |
if (!(obj1 == null ? obj2 == null : obj1.equals(obj2))) { |
| 262 |
1
1. isEqualList : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return false; |
| 263 | } | |
| 264 | } | |
| 265 | ||
| 266 |
3
1. isEqualList : negated conditional → NO_COVERAGE 2. isEqualList : negated conditional → NO_COVERAGE 3. isEqualList : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return !(it1.hasNext() || it2.hasNext()); |
| 267 | } | |
| 268 | ||
| 269 | /** | |
| 270 | * Generates a hash code using the algorithm specified in | |
| 271 | * {@link java.util.List#hashCode()}. | |
| 272 | *
 | |
| 273 | * This method is useful for implementing List when you cannot | |
| 274 | * extend AbstractList. The method takes Collection instances to enable other | |
| 275 | * collection types to use the List implementation algorithm. | |
| 276 | * | |
| 277 | * @see java.util.List#hashCode() | |
| 278 | * @param list the list to generate the hashCode for, may be null | |
| 279 | * @return the hash code | |
| 280 | */ | |
| 281 | public static int hashCodeForList(final Collection<?> list) { | |
| 282 |
1
1. hashCodeForList : negated conditional → NO_COVERAGE |
if (list == null) { |
| 283 |
1
1. hashCodeForList : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return 0; |
| 284 | } | |
| 285 | int hashCode = 1; | |
| 286 | final Iterator<?> it = list.iterator(); | |
| 287 | ||
| 288 |
1
1. hashCodeForList : negated conditional → NO_COVERAGE |
while (it.hasNext()) { |
| 289 | final Object obj = it.next(); | |
| 290 |
3
1. hashCodeForList : Replaced integer multiplication with division → NO_COVERAGE 2. hashCodeForList : Replaced integer addition with subtraction → NO_COVERAGE 3. hashCodeForList : negated conditional → NO_COVERAGE |
hashCode = 31 * hashCode + (obj == null ? 0 : obj.hashCode()); |
| 291 | } | |
| 292 |
1
1. hashCodeForList : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return hashCode; |
| 293 | } | |
| 294 | ||
| 295 | //----------------------------------------------------------------------- | |
| 296 | /** | |
| 297 | * Returns a List containing all the elements in collection | |
| 298 | * that are also in retain. The cardinality of an element e | |
| 299 | * in the returned list is the same as the cardinality of e | |
| 300 | * in collection unless retain does not contain e, in which | |
| 301 | * case the cardinality is zero. This method is useful if you do not wish to modify | |
| 302 | * the collection c and thus cannot call collection.retainAll(retain);. | |
| 303 | *
 | |
| 304 | * This implementation iterates over collection, checking each element in | |
| 305 | * turn to see if it's contained in retain. If it's contained, it's added | |
| 306 | * to the returned list. As a consequence, it is advised to use a collection type for | |
| 307 | * retain that provides a fast (e.g. O(1)) implementation of | |
| 308 | * {@link Collection#contains(Object)}. | |
| 309 | * | |
| 310 | * @param <E> the element type | |
| 311 | * @param collection the collection whose contents are the target of the #retailAll operation | |
| 312 | * @param retain the collection containing the elements to be retained in the returned collection | |
| 313 | * @return a List containing all the elements of c | |
| 314 | * that occur at least once in retain. | |
| 315 | * @throws NullPointerException if either parameter is null | |
| 316 | * @since 3.2 | |
| 317 | */ | |
| 318 | public static <E> List<E> retainAll(final Collection<E> collection, final Collection<?> retain) { | |
| 319 | final List<E> list = new ArrayList<E>(Math.min(collection.size(), retain.size())); | |
| 320 | ||
| 321 |
1
1. retainAll : negated conditional → KILLED |
for (final E obj : collection) { |
| 322 |
1
1. retainAll : negated conditional → KILLED |
if (retain.contains(obj)) { |
| 323 | list.add(obj); | |
| 324 | } | |
| 325 | } | |
| 326 |
1
1. retainAll : mutated return of Object value for org/apache/commons/collections4/ListUtils::retainAll to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return list; |
| 327 | } | |
| 328 | ||
| 329 | /** | |
| 330 | * Removes the elements in remove from collection. That is, this | |
| 331 | * method returns a list containing all the elements in collection | |
| 332 | * that are not in remove. The cardinality of an element e | |
| 333 | * in the returned collection is the same as the cardinality of e | |
| 334 | * in collection unless remove contains e, in which | |
| 335 | * case the cardinality is zero. This method is useful if you do not wish to modify | |
| 336 | * collection and thus cannot call collection.removeAll(remove);. | |
| 337 | *
 | |
| 338 | * This implementation iterates over collection, checking each element in | |
| 339 | * turn to see if it's contained in remove. If it's not contained, it's added | |
| 340 | * to the returned list. As a consequence, it is advised to use a collection type for | |
| 341 | * remove that provides a fast (e.g. O(1)) implementation of | |
| 342 | * {@link Collection#contains(Object)}. | |
| 343 | * | |
| 344 | * @param <E> the element type | |
| 345 | * @param collection the collection from which items are removed (in the returned collection) | |
| 346 | * @param remove the items to be removed from the returned collection | |
| 347 | * @return a List containing all the elements of c except | |
| 348 | * any elements that also occur in remove. | |
| 349 | * @throws NullPointerException if either parameter is null | |
| 350 | * @since 3.2 | |
| 351 | */ | |
| 352 | public static <E> List<E> removeAll(final Collection<E> collection, final Collection<?> remove) { | |
| 353 | final List<E> list = new ArrayList<E>(); | |
| 354 |
1
1. removeAll : negated conditional → KILLED |
for (final E obj : collection) { |
| 355 |
1
1. removeAll : negated conditional → KILLED |
if (!remove.contains(obj)) { |
| 356 | list.add(obj); | |
| 357 | } | |
| 358 | } | |
| 359 |
1
1. removeAll : mutated return of Object value for org/apache/commons/collections4/ListUtils::removeAll to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return list; |
| 360 | } | |
| 361 | ||
| 362 | //----------------------------------------------------------------------- | |
| 363 | /** | |
| 364 | * Returns a synchronized list backed by the given list. | |
| 365 | *
 | |
| 366 | * You must manually synchronize on the returned list's iterator to | |
| 367 | * avoid non-deterministic behavior: | |
| 368 | * | |
| 369 | *
 | |
| 370 | * List list = ListUtils.synchronizedList(myList); | |
| 371 | * synchronized (list) { | |
| 372 | * Iterator i = list.iterator(); | |
| 373 | * while (i.hasNext()) { | |
| 374 | * process (i.next()); | |
| 375 | * } | |
| 376 | * } | |
| 377 | *
 | |
| 378 | * | |
| 379 | * This method is just a wrapper for {@link Collections#synchronizedList(List)}. | |
| 380 | * | |
| 381 | * @param <E> the element type | |
| 382 | * @param list the list to synchronize, must not be null | |
| 383 | * @return a synchronized list backed by the given list | |
| 384 | * @throws IllegalArgumentException if the list is null | |
| 385 | */ | |
| 386 | public static <E> List<E> synchronizedList(final List<E> list) { | |
| 387 |
1
1. synchronizedList : mutated return of Object value for org/apache/commons/collections4/ListUtils::synchronizedList to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return Collections.synchronizedList(list); |
| 388 | } | |
| 389 | ||
| 390 | /** | |
| 391 | * Returns an unmodifiable list backed by the given list. | |
| 392 | *
 | |
| 393 | * This method uses the implementation in the decorators subpackage. | |
| 394 | * | |
| 395 | * @param <E> the element type | |
| 396 | * @param list the list to make unmodifiable, must not be null | |
| 397 | * @return an unmodifiable list backed by the given list | |
| 398 | * @throws IllegalArgumentException if the list is null | |
| 399 | */ | |
| 400 | public static <E> List<E> unmodifiableList(final List<? extends E> list) { | |
| 401 |
1
1. unmodifiableList : mutated return of Object value for org/apache/commons/collections4/ListUtils::unmodifiableList to ( if (x != null) null else throw new RuntimeException ) → KILLED |
return UnmodifiableList.unmodifiableList(list); |
| 402 | } | |
| 403 | ||
| 404 | /** | |
| 405 | * Returns a predicated (validating) list backed by the given list. | |
| 406 | *
 | |
| 407 | * Only objects that pass the test in the given predicate can be added to the list. | |
| 408 | * Trying to add an invalid object results in an IllegalArgumentException. | |
| 409 | * It is important not to use the original list after invoking this method, | |
| 410 | * as it is a backdoor for adding invalid objects. | |
| 411 | * | |
| 412 | * @param <E> the element type | |
| 413 | * @param list the list to predicate, must not be null | |
| 414 | * @param predicate the predicate for the list, must not be null | |
| 415 | * @return a predicated list backed by the given list | |
| 416 | * @throws IllegalArgumentException if the List or Predicate is null | |
| 417 | */ | |
| 418 | public static <E> List<E> predicatedList(final List<E> list, final Predicate<E> predicate) { | |
| 419 |
1
1. predicatedList : mutated return of Object value for org/apache/commons/collections4/ListUtils::predicatedList to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return PredicatedList.predicatedList(list, predicate); |
| 420 | } | |
| 421 | ||
| 422 | /** | |
| 423 | * Returns a transformed list backed by the given list. | |
| 424 | *
 | |
| 425 | * This method returns a new list (decorating the specified list) that | |
| 426 | * will transform any new entries added to it. | |
| 427 | * Existing entries in the specified list will not be transformed. | |
| 428 | *
 | |
| 429 | * Each object is passed through the transformer as it is added to the | |
| 430 | * List. It is important not to use the original list after invoking this | |
| 431 | * method, as it is a backdoor for adding untransformed objects. | |
| 432 | *
 | |
| 433 | * Existing entries in the specified list will not be transformed. | |
| 434 | * If you want that behaviour, see {@link TransformedList#transformedList}. | |
| 435 | * | |
| 436 | * @param <E> the element type | |
| 437 | * @param list the list to predicate, must not be null | |
| 438 | * @param transformer the transformer for the list, must not be null | |
| 439 | * @return a transformed list backed by the given list | |
| 440 | * @throws IllegalArgumentException if the List or Transformer is null | |
| 441 | */ | |
| 442 | public static <E> List<E> transformedList(final List<E> list, | |
| 443 | final Transformer<? super E, ? extends E> transformer) { | |
| 444 |
1
1. transformedList : mutated return of Object value for org/apache/commons/collections4/ListUtils::transformedList to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return TransformedList.transformingList(list, transformer); |
| 445 | } | |
| 446 | ||
| 447 | /** | |
| 448 | * Returns a "lazy" list whose elements will be created on demand. | |
| 449 | *
 | |
| 450 | * When the index passed to the returned list's {@link List#get(int) get} | |
| 451 | * method is greater than the list's size, then the factory will be used | |
| 452 | * to create a new object and that object will be inserted at that index. | |
| 453 | *
 | |
| 454 | * For instance: | |
| 455 | * | |
| 456 | *
 | |
| 457 | * Factory<Date> factory = new Factory<Date>() { | |
| 458 | * public Date create() { | |
| 459 | * return new Date(); | |
| 460 | * } | |
| 461 | * } | |
| 462 | * List<Date> lazy = ListUtils.lazyList(new ArrayList<Date>(), factory); | |
| 463 | * Date date = lazy.get(3); | |
| 464 | *
 | |
| 465 | * | |
| 466 | * After the above code is executed, date will refer to | |
| 467 | * a new Date instance. Furthermore, that Date | |
| 468 | * instance is the fourth element in the list. The first, second, | |
| 469 | * and third element are all set to null. | |
| 470 | * | |
| 471 | * @param <E> the element type | |
| 472 | * @param list the list to make lazy, must not be null | |
| 473 | * @param factory the factory for creating new objects, must not be null | |
| 474 | * @return a lazy list backed by the given list | |
| 475 | * @throws IllegalArgumentException if the List or Factory is null | |
| 476 | */ | |
| 477 | public static <E> List<E> lazyList(final List<E> list, final Factory<? extends E> factory) { | |
| 478 |
1
1. lazyList : mutated return of Object value for org/apache/commons/collections4/ListUtils::lazyList to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return LazyList.lazyList(list, factory); |
| 479 | } | |
| 480 | ||
| 481 | /** | |
| 482 | * Returns a fixed-sized list backed by the given list. | |
| 483 | * Elements may not be added or removed from the returned list, but | |
| 484 | * existing elements can be changed (for instance, via the | |
| 485 | * {@link List#set(int, Object)} method). | |
| 486 | * | |
| 487 | * @param <E> the element type | |
| 488 | * @param list the list whose size to fix, must not be null | |
| 489 | * @return a fixed-size list backed by that list | |
| 490 | * @throws IllegalArgumentException if the List is null | |
| 491 | */ | |
| 492 | public static <E> List<E> fixedSizeList(final List<E> list) { | |
| 493 |
1
1. fixedSizeList : mutated return of Object value for org/apache/commons/collections4/ListUtils::fixedSizeList to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return FixedSizeList.fixedSizeList(list); |
| 494 | } | |
| 495 | ||
| 496 | //----------------------------------------------------------------------- | |
| 497 | /** | |
| 498 | * Finds the first index in the given List which matches the given predicate. | |
| 499 | *
 | |
| 500 | * If the input List or predicate is null, or no element of the List | |
| 501 | * matches the predicate, -1 is returned. | |
| 502 | * | |
| 503 | * @param <E> the element type | |
| 504 | * @param list the List to search, may be null | |
| 505 | * @param predicate the predicate to use, may be null | |
| 506 | * @return the first index of an Object in the List which matches the predicate or -1 if none could be found | |
| 507 | */ | |
| 508 | public static <E> int indexOf(final List<E> list, final Predicate<E> predicate) { | |
| 509 |
2
1. indexOf : negated conditional → NO_COVERAGE 2. indexOf : negated conditional → NO_COVERAGE |
if (list != null && predicate != null) { |
| 510 |
3
1. indexOf : changed conditional boundary → NO_COVERAGE 2. indexOf : Changed increment from 1 to -1 → NO_COVERAGE 3. indexOf : negated conditional → NO_COVERAGE |
for (int i = 0; i < list.size(); i++) { |
| 511 | final E item = list.get(i); | |
| 512 |
1
1. indexOf : negated conditional → NO_COVERAGE |
if (predicate.evaluate(item)) { |
| 513 |
1
1. indexOf : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return i; |
| 514 | } | |
| 515 | } | |
| 516 | } | |
| 517 |
1
1. indexOf : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return -1; |
| 518 | } | |
| 519 | ||
| 520 | //----------------------------------------------------------------------- | |
| 521 | /** | |
| 522 | * Returns the longest common subsequence (LCS) of two sequences (lists). | |
| 523 | * | |
| 524 | * @param <E> the element type | |
| 525 | * @param a the first list | |
| 526 | * @param b the second list | |
| 527 | * @return the longest common subsequence | |
| 528 | * @throws IllegalArgumentException if either list is {@code null} | |
| 529 | * @since 4.0 | |
| 530 | */ | |
| 531 | public static <E> List<E> longestCommonSubsequence(final List<E> a, final List<E> b) { | |
| 532 |
1
1. longestCommonSubsequence : mutated return of Object value for org/apache/commons/collections4/ListUtils::longestCommonSubsequence to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return longestCommonSubsequence( a, b, DefaultEquator.defaultEquator() ); |
| 533 | } | |
| 534 | ||
| 535 | /** | |
| 536 | * Returns the longest common subsequence (LCS) of two sequences (lists). | |
| 537 | * | |
| 538 | * @param <E> the element type | |
| 539 | * @param a the first list | |
| 540 | * @param b the second list | |
| 541 | * @param equator the equator used to test object equality | |
| 542 | * @return the longest common subsequence | |
| 543 | * @throws IllegalArgumentException if either list or the equator is {@code null} | |
| 544 | * @since 4.0 | |
| 545 | */ | |
| 546 | public static <E> List<E> longestCommonSubsequence(final List<E> a, final List<E> b, | |
| 547 | final Equator<? super E> equator) { | |
| 548 |
2
1. longestCommonSubsequence : negated conditional → NO_COVERAGE 2. longestCommonSubsequence : negated conditional → NO_COVERAGE |
if (a == null || b == null) { |
| 549 | throw new IllegalArgumentException("List must not be null"); | |
| 550 | } | |
| 551 |
1
1. longestCommonSubsequence : negated conditional → NO_COVERAGE |
if (equator == null) { |
| 552 | throw new IllegalArgumentException("Equator must not be null"); | |
| 553 | } | |
| 554 | ||
| 555 | final SequencesComparator<E> comparator = new SequencesComparator<E>(a, b, equator); | |
| 556 | final EditScript<E> script = comparator.getScript(); | |
| 557 | final LcsVisitor<E> visitor = new LcsVisitor<E>(); | |
| 558 |
1
1. longestCommonSubsequence : removed call to org/apache/commons/collections4/sequence/EditScript::visit → NO_COVERAGE |
script.visit(visitor); |
| 559 |
1
1. longestCommonSubsequence : mutated return of Object value for org/apache/commons/collections4/ListUtils::longestCommonSubsequence to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return visitor.getSubSequence(); |
| 560 | } | |
| 561 | ||
| 562 | /** | |
| 563 | * Returns the longest common subsequence (LCS) of two {@link CharSequence} objects. | |
| 564 | *
 | |
| 565 | * This is a convenience method for using {@link #longestCommonSubsequence(List, List)} | |
| 566 | * with {@link CharSequence} instances. | |
| 567 | * | |
| 568 | * @param a the first sequence | |
| 569 | * @param b the second sequence | |
| 570 | * @return the longest common subsequence as {@link String} | |
| 571 | * @throws IllegalArgumentException if either sequence is {@code null} | |
| 572 | * @since 4.0 | |
| 573 | */ | |
| 574 | public static String longestCommonSubsequence(final CharSequence a, final CharSequence b) { | |
| 575 |
2
1. longestCommonSubsequence : negated conditional → NO_COVERAGE 2. longestCommonSubsequence : negated conditional → NO_COVERAGE |
if (a == null || b == null) { |
| 576 | throw new IllegalArgumentException("CharSequence must not be null"); | |
| 577 | } | |
| 578 | final List<Character> lcs = longestCommonSubsequence(new CharSequenceAsList( a ), new CharSequenceAsList( b )); | |
| 579 | final StringBuilder sb = new StringBuilder(); | |
| 580 |
1
1. longestCommonSubsequence : negated conditional → NO_COVERAGE |
for ( Character ch : lcs ) { |
| 581 | sb.append(ch); | |
| 582 | } | |
| 583 |
1
1. longestCommonSubsequence : mutated return of Object value for org/apache/commons/collections4/ListUtils::longestCommonSubsequence to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return sb.toString(); |
| 584 | } | |
| 585 | ||
| 586 | /** | |
| 587 | * A helper class used to construct the longest common subsequence. | |
| 588 | */ | |
| 589 | private static final class LcsVisitor<E> implements CommandVisitor<E> { | |
| 590 | private ArrayList<E> sequence; | |
| 591 | ||
| 592 | public LcsVisitor() { | |
| 593 | sequence = new ArrayList<E>(); | |
| 594 | } | |
| 595 | ||
| 596 | public void visitInsertCommand(final E object) {} | |
| 597 | ||
| 598 | public void visitDeleteCommand(final E object) {} | |
| 599 | ||
| 600 | public void visitKeepCommand(final E object) { | |
| 601 | sequence.add(object); | |
| 602 | } | |
| 603 | ||
| 604 | public List<E> getSubSequence() { | |
| 605 |
1
1. getSubSequence : mutated return of Object value for org/apache/commons/collections4/ListUtils$LcsVisitor::getSubSequence to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return sequence; |
| 606 | } | |
| 607 | } | |
| 608 | ||
| 609 | /** | |
| 610 | * A simple wrapper to use a CharSequence as List. | |
| 611 | */ | |
| 612 | private static final class CharSequenceAsList extends AbstractList<Character> { | |
| 613 | ||
| 614 | private final CharSequence sequence; | |
| 615 | ||
| 616 | public CharSequenceAsList(final CharSequence sequence) { | |
| 617 | this.sequence = sequence; | |
| 618 | } | |
| 619 | ||
| 620 | @Override | |
| 621 | public Character get( int index ) { | |
| 622 |
1
1. get : mutated return of Object value for org/apache/commons/collections4/ListUtils$CharSequenceAsList::get to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return Character.valueOf(sequence.charAt( index )); |
| 623 | } | |
| 624 | ||
| 625 | @Override | |
| 626 | public int size() { | |
| 627 |
1
1. size : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return sequence.length(); |
| 628 | } | |
| 629 | ||
| 630 | } | |
| 631 | ||
| 632 | //----------------------------------------------------------------------- | |
| 633 | /** | |
| 634 | * Returns consecutive {@link List#subList(int, int) sublists} of a | |
| 635 | * list, each of the same size (the final list may be smaller). For example, | |
| 636 | * partitioning a list containing {@code [a, b, c, d, e]} with a partition | |
| 637 | * size of 3 yields {@code [[a, b, c], [d, e]]} -- an outer list containing | |
| 638 | * two inner lists of three and two elements, all in the original order. | |
| 639 | *
 | |
| 640 | * The outer list is unmodifiable, but reflects the latest state of the | |
| 641 | * source list. The inner lists are sublist views of the original list, | |
| 642 | * produced on demand using {@link List#subList(int, int)}, and are subject | |
| 643 | * to all the usual caveats about modification as explained in that API. | |
| 644 | *
 | |
| 645 | * Adapted from http://code.google.com/p/guava-libraries/ | |
| 646 | * | |
| 647 | * @param <T> the element type | |
| 648 | * @param list the list to return consecutive sublists of | |
| 649 | * @param size the desired size of each sublist (the last may be smaller) | |
| 650 | * @return a list of consecutive sublists | |
| 651 | * @throws IllegalArgumentException if list is {@code null} or size is not strictly positive | |
| 652 | * @since 4.0 | |
| 653 | */ | |
| 654 | public static <T> List<List<T>> partition(final List<T> list, final int size) { | |
| 655 |
1
1. partition : negated conditional → NO_COVERAGE |
if (list == null) { |
| 656 | throw new IllegalArgumentException("List must not be null"); | |
| 657 | } | |
| 658 |
2
1. partition : changed conditional boundary → NO_COVERAGE 2. partition : negated conditional → NO_COVERAGE |
if (size <= 0) { |
| 659 | throw new IllegalArgumentException("Size must be greater than 0"); | |
| 660 | } | |
| 661 |
1
1. partition : mutated return of Object value for org/apache/commons/collections4/ListUtils::partition to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return new Partition<T>(list, size); |
| 662 | } | |
| 663 | ||
| 664 | /** | |
| 665 | * Provides a partition view on a {@link List}. | |
| 666 | * @since 4.0 | |
| 667 | */ | |
| 668 | private static class Partition<T> extends AbstractList<List<T>> { | |
| 669 | private final List<T> list; | |
| 670 | private final int size; | |
| 671 | ||
| 672 | private Partition(final List<T> list, final int size) { | |
| 673 | this.list = list; | |
| 674 | this.size = size; | |
| 675 | } | |
| 676 | ||
| 677 | @Override | |
| 678 | public List<T> get(final int index) { | |
| 679 | final int listSize = size(); | |
| 680 |
2
1. get : changed conditional boundary → NO_COVERAGE 2. get : negated conditional → NO_COVERAGE |
if (listSize < 0) { |
| 681 | throw new IllegalArgumentException("negative size: " + listSize); | |
| 682 | } | |
| 683 |
2
1. get : changed conditional boundary → NO_COVERAGE 2. get : negated conditional → NO_COVERAGE |
if (index < 0) { |
| 684 | throw new IndexOutOfBoundsException("Index " + index + " must not be negative"); | |
| 685 | } | |
| 686 |
2
1. get : changed conditional boundary → NO_COVERAGE 2. get : negated conditional → NO_COVERAGE |
if (index >= listSize) { |
| 687 | throw new IndexOutOfBoundsException("Index " + index + " must be less than size " + | |
| 688 | listSize); | |
| 689 | } | |
| 690 |
1
1. get : Replaced integer multiplication with division → NO_COVERAGE |
final int start = index * size; |
| 691 |
1
1. get : Replaced integer addition with subtraction → NO_COVERAGE |
final int end = Math.min(start + size, list.size()); |
| 692 |
1
1. get : mutated return of Object value for org/apache/commons/collections4/ListUtils$Partition::get to ( if (x != null) null else throw new RuntimeException ) → NO_COVERAGE |
return list.subList(start, end); |
| 693 | } | |
| 694 | ||
| 695 | @Override | |
| 696 | public int size() { | |
| 697 |
4
1. size : Replaced integer addition with subtraction → NO_COVERAGE 2. size : Replaced integer subtraction with addition → NO_COVERAGE 3. size : Replaced integer division with multiplication → NO_COVERAGE 4. size : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return (list.size() + size - 1) / size; |
| 698 | } | |
| 699 | ||
| 700 | @Override | |
| 701 | public boolean isEmpty() { | |
| 702 |
1
1. isEmpty : replaced return of integer sized value with (x == 0 ? 1 : 0) → NO_COVERAGE |
return list.isEmpty(); |
| 703 | } | |
| 704 | } | |
| 705 | } | |
Mutations | ||
| 62 |
1.1 2.2 |
|
| 76 |
1.1 2.2 |
|
| 94 |
1.1 2.2 |
|
| 101 |
1.1 |
|
| 102 |
1.1 |
|
| 107 |
1.1 |
|
| 129 |
1.1 |
|
| 130 |
1.1 |
|
| 134 |
1.1 |
|
| 148 |
1.1 |
|
| 165 |
1.1 |
|
| 188 |
1.1 |
|
| 212 |
1.1 |
|
| 245 |
1.1 |
|
| 246 |
1.1 |
|
| 248 |
1.1 2.2 3.3 |
|
| 249 |
1.1 |
|
| 257 |
1.1 2.2 |
|
| 261 |
1.1 2.2 3.3 |
|
| 262 |
1.1 |
|
| 266 |
1.1 2.2 3.3 |
|
| 282 |
1.1 |
|
| 283 |
1.1 |
|
| 288 |
1.1 |
|
| 290 |
1.1 2.2 3.3 |
|
| 292 |
1.1 |
|
| 321 |
1.1 |
|
| 322 |
1.1 |
|
| 326 |
1.1 |
|
| 354 |
1.1 |
|
| 355 |
1.1 |
|
| 359 |
1.1 |
|
| 387 |
1.1 |
|
| 401 |
1.1 |
|
| 419 |
1.1 |
|
| 444 |
1.1 |
|
| 478 |
1.1 |
|
| 493 |
1.1 |
|
| 509 |
1.1 2.2 |
|
| 510 |
1.1 2.2 3.3 |
|
| 512 |
1.1 |
|
| 513 |
1.1 |
|
| 517 |
1.1 |
|
| 532 |
1.1 |
|
| 548 |
1.1 2.2 |
|
| 551 |
1.1 |
|
| 558 |
1.1 |
|
| 559 |
1.1 |
|
| 575 |
1.1 2.2 |
|
| 580 |
1.1 |
|
| 583 |
1.1 |
|
| 605 |
1.1 |
|
| 622 |
1.1 |
|
| 627 |
1.1 |
|
| 655 |
1.1 |
|
| 658 |
1.1 2.2 |
|
| 661 |
1.1 |
|
| 680 |
1.1 2.2 |
|
| 683 |
1.1 2.2 |
|
| 686 |
1.1 2.2 |
|
| 690 |
1.1 |
|
| 691 |
1.1 |
|
| 692 |
1.1 |
|
| 697 |
1.1 2.2 3.3 4.4 |
|
| 702 |
1.1 |


TSTest is a simple unit testing library for TypeScript.
Unit tests are classes that extend the TSTest.UnitTest class. Test methods must start with "test", e.g. "testSomething()". This allows you to have any other supporting methods inside your unit test class. You may also implement setUp() and tearDown() methods. The setUp() method is called before any tests are run and tearDown() is called after all tests have run.
class MyUnitTest extends TSTest.UnitTest { public testSomething() { //... } }
Next you use the built-in Assert class to implement tests. Assert has the following assertion methods. They all take a name parameter which you can use to uniquely identify tests to help you find them when there are failures.
- isTrue(bool, name)
- isFalse(bool, name)
- areIdentical(expected, actual, name) - Determines if two objects are identical using strict equality operator (===)
- notIdentical(expected, actual, name) - Determines if two objects are not identical using strict equality operator (===)
- areEqual(expected, actual, name) - Determines if two objects are equal using equality operator (==)
- notEqual(expected, actual, name) - Determines if two objects are not equal using equality operator (==)
Please note that TSTest does not supply methods to check if two objects or arrays are identical. It only uses the equality operators therefore only primitive types (string, number, bool) are correctly compared.
public testSomething() { this.assert.areEqual(4, add(3, 1), "add(3, 1) is 4"); }
Once you have unit tests you can create a test suite and add your unit tests to them.
var testSuite = new TSTest.UnitTestSuite(); testSuite.addUnitTest(new MyUnitTest());
Results are printed out to the browser's console window by default. If you would also like the results printed to your web page you can add an element logger.
testSuite.addLogger(new ElementLogger());
When your test suite is all set up you run it.
testSuite.run();
That's it! Happy unit testing.


Pianist, Music Producer, Songwriter, Musician, Singer
A young Stevie Wonder performing in 1973
The Wonder TimeLine
A timeline of the life of Stevie Wonder
1950 - 13th May Stevie is born
1954 - Stevie receives his first instrument a 6-hole Harmonica
1961 - Stevie signs recording contract with Motown
1963 - Fingertips single reached #1 on Billboard Pop Charts
1965 - Uptight album released. Uptight single hit #1 R&B and #3 Pop
1966 - Down To Earth album #8R&B #72Pop
1967 - I Was Made To Love Her album #7R&B #45Pop
1968 - Graduated with honours from the Michigan School for the Blind
Stevie releases four albums: Someday At Christmas, Greatest Hits, Eivets Rednow, For Once In My Life
1969 - Received the Distinguished Service Award from President Nixon
My Cherie Amour album peaked #3 R&B 34 Pop
1970 - Marriage to Syreeta
Produced & Arranged the album Signed, Sealed, Delivered, #7R&B, 25Pop
1971 - Groundbreaking album Where I'm Comin' From, deviates from the Motown standard
Second five year contract with Motown expires, Stevie does not renew immediately
Stevie meets synthesizer engineers Robert Margoulef and Malcolm Cecil in New York
1972 - Music of My Mind and Talking Book albums released
Stevie tours US with The Rolling Stones ones
Produced and arranged album 'Syreeta' for Syreeta
Stevie's marriage to Syreeta ends in Divorce
1973 - August 6th car accident puts Stevie in Coma for 10 days
Innervisions album release
1974 - Stevie picks up 5 Grammies
Fulfillingness' First Finale album released
Produced albums for Syreeta and Minnie Riperton
18th Nov declared Stevie Wonder Day in LA
1975 - Stevie picks up 5 Grammies
April 1975 Yolanda Simmons gives birth to Stevie's first child, Aisha
Stevie signs $13M contract the then largest in music industry history
1976 - Songs in the Key of Life debuts at #1 on Pop and R&B charts
1977 - Stevie picks up 4 Grammies. Starts work on soundtrack to movie
1979 - Secret Life of Plants is released peaking at #4 on Pop and R&B charts
1980 - Hotter Than July released peaking at #1 R&B #3 pop and #2 UK
Stevie embarks on campaign to make Martin Luther King's birthday a National Holiday in the UShe US
1982 - Work with Paul McCartney (Ebony & Ivory) and Third World (Try Jah Love)
1983 - Stevie buys LA radio station KHLH. Release Original Musiquarium greatest hits
Bill passed declaring MLK birthday a holidayliday
1984 - Soundtrack to The Woman In Red movie released
I Just To Say I Love You gives Stevie his first UK #1 single
1985 - Release of In Square Circle reaching #1 R&B #5 Pop
Receives an Oscar for I Just Called to Say I love You
Stevie is arrested for demonstrating against apartheid outside the South African Embassy
1986 - Wins Grammy for That's What Friends Are For with Dionne, Elton and Gladys
Celebrates the first observance of MLK Day in televised event
1987 - Release of Characters album peaking at #1 R&B and #17 Pop
1989 - Inducted in the Rock and Roll Hall of Fame
1991 - Release of Jungle Fever Motion Picture Soundtrack charting at #1 R&B, 24 Pop
1995 - Conversation Peace release peaking at #2 R&B, #16 Pop
1996 - Picks up 2 Grammys for For Your Love
Awarded the Grammy Lifetime Achievement Award
1998 - Performs a specially penned song at Pavrotti's War Child charity concert
1999 - Boxset At The Close Of A Century released
Receives 2 Grammys for work on Hancock's album
Received the Polar Music Prize in Sweden and honoured by the Kennedy Center
2001 - Stevie performs at Detroit's 300th anniversary celebration
Receives Ivor Novello Lifetime Achievement Award
2002 - Awarded the Songwriters Hall of Fame Lifetime Achievement Award
2003 - Honoured with BET Walk Of Fame Award
2004 - July, Syreeta dies at age 58
Stevie receives Billboard Century Award - Lifetime Achievement
2005 - Release of A Time To Love album peaking at #2 R&B, #5 Pop
2006 - Stevie's mother, Lula Mae Hardaway, passes away age 74
Honoured with the National Artistic Achievement Award
2007 - Honoured at the 4th Annual Alfred Mann Foundation Gala
2008 - Receives The NAACP Hall of Fame Award
2009 - Awarded the Library of Congress Gershwin Prize and commissioned to write a classical piece for the Library
Designated a UN Messenger of Peace
2010 - Receives France's highest honour for Arts & Literature
Receives the first Image Award presented by the American Association of People with Disabilities
Headlines Bonnaroo and Glastonbury festivals on either side of the Atlantic
"Stevie Wonder is one of the most incredible singer songwriters in history and one of the most beautiful spirits in the entire world."
If you have time, you should read more about this incredible human being on his Wikipedia entry


- readBlueprint(String) - Static method in class blitzEdit.storage.XMLParser
-
Reads an xml file and extracts the strings used for a ComponentBlueprint.
- readBlueprintValues(String, String, ArrayList<String>, ArrayList<String>, File) - Static method in class blitzEdit.storage.XMLParser
-
Reads the strings given as parameter for xml properties and creates a ComponentBlueprint with them.
- readComponent(String) - Method in class blitzEdit.storage.XMLParser
-
Creates a component element out of the given xml string.
- readConnector(String) - Method in class blitzEdit.storage.XMLParser
-
Creates a connector out of given xml string.
- readFile(String, Charset) - Static method in class tools.FileTools
-
Reads the given file by reading all bytes of it and saving it into a string.
- rect - Variable in class blitzEdit.core.ComponentLibrary.LibraryEntry
-
- ref - Variable in class blitzEdit.application.CircuitCanvas
-
- refreshCanvas() - Method in class blitzEdit.application.CircuitCanvas
-
Used for redrawing the content of the canvas when changes to elements of the circuit occured.
- Reload - Variable in class blitzEdit.application.BlitzEdit
-
- removeBlueprints(ComponentBlueprint[]) - Method in class blitzEdit.core.BlueprintContainer
-
Tries to delete all ComponentBlueprints in the given array from its blueprints array.
- removeCurrentLibraryTitlesPane() - Method in class blitzEdit.application.BlitzEdit
-
Removes the current selected TitledPane from the accordion and the library from libraries array.
- removeElement(Element) - Method in class blitzEdit.core.Circuit
-
Removes Element from Circuit
- renderRect(String, GraphicsContext, double, double, double, double) - Static method in class tools.SvgRenderer
-
Used for drawing a rotated rectangle on a graphical context.
- renderSvgString(String, GraphicsContext, double, double, double, SelectionMode) - Static method in class tools.SvgRenderer
-
Used for drawing a svg image of an
Element
on a graphical context.
- renderSvgString(String, GraphicsContext, double, double, double, double, SelectionMode) - Static method in class tools.SvgRenderer
-
Used for drawing a rotated svg image of an
Element
on a graphical context.
- ResizableCanvas - Class in blitzEdit.application
-
- ResizableCanvas() - Constructor for class blitzEdit.application.ResizableCanvas
-
- resize(double, double) - Method in class blitzEdit.application.CircuitCanvas
-
- resize(double, double) - Method in class blitzEdit.application.LibraryCanvas
-
- resize(double, double) - Method in class blitzEdit.application.ResizableCanvas
-
- rightClickMenu - Variable in class blitzEdit.application.CircuitCanvas
-
- RotatableElement - Class in blitzEdit.core
-
abstract class for rotatable elements in a circuit
- RotatableElement(int, int, int, int, short) - Constructor for class blitzEdit.core.RotatableElement
-
Constructs new RotatableElement
- RotatableElement(int, int, short) - Constructor for class blitzEdit.core.RotatableElement
-
Constructs new RotatableElement.
- RotatableElement() - Constructor for class blitzEdit.core.RotatableElement
-
Constructs new RotatableElement
- RotatableRectangle - Class in tools
-
Used for rotating a rectangle around his center and getting information about intersections and overlaps.
- RotatableRectangle(double, double, double, double) - Constructor for class tools.RotatableRectangle
-
Constructor
- RotatableRectangle(double, double, double, double, Point) - Constructor for class tools.RotatableRectangle
-
Constructor
- RotatableRectangle(ArrayList<Point>, Point) - Constructor for class tools.RotatableRectangle
-
Constructor
Size of the points array need to be exactly four.
- RotatableRectangle(Point, Point, Point, Point) - Constructor for class tools.RotatableRectangle
-
Constructor
- RotatableRectangle(Point, Point, Point, Point, Point) - Constructor for class tools.RotatableRectangle
-
Constructor
- rotate(short) - Method in class blitzEdit.core.Component
-
- rotate(short) - Method in class blitzEdit.core.RotatableElement
-
rotates this element by the specified angle in degrees
- rotatePoint(double, Point) - Method in class tools.RotatableRectangle
-
Used when rotating on of the corners around the center of this rectangle.
- rotateRect(double) - Method in class tools.RotatableRectangle
-
Used to rotate this rectangle for angle degrees
- rotateSelectedElements(double) - Method in class blitzEdit.application.CircuitCanvas
-
Rotates the selected components in the canvas.
- rotationPoint - Static variable in class tools.SvgRenderer
-


@(title: String, name: String, description: String, currentApp: TestApp)
@description
Applications can be configured by users. You can view application setup here and can set up/edit/delete your application.
View details »
Historical results per application can be found here.
Check out which tests are running and results.


Filter entities demos.

- Copyright
- Copyright (c) 2017-2019, New York University and Max Planck Gesellschaft, License BSD-3-Clause