Runes – Zen Spiritual | Gifts, Herbs, Cowrie Shells, Bath Herbs, Incense for sale and more.
If you are new to an alternative spiritual path, and along the way, you've done a brief bit of research on some things your friends told you about, such as crystals, divination tools and so on, you might have come across a combination of the following: Norse runes (aka 'Elder Futhark') carved into pieces of amethyst.
This is an excellent question, and the information given will help you understand more.
Let's start with the stone itself. If you haven't looked much into crystals, amethyst is one of the best ones to start with, as it is one of the best-known, next to clear quartz.
Amethyst has long ben celebrated as a stone that's associated with the third eye chakra, the one situated between—and just slightly above—your physical eyes. The third eye is often the seat of clairvoyance and other 'mind's-eye' activities, such as dreaming. Amethyst aids in clearing and using the third-eye chakra and aids in using other intuitive gifts that include the ability to use divination tools, such as the Norse runes.
There are other stones associated with the third eye, but amethyst is, essentially the 'star' of the 'show' as it were. Long ago, in ancient Greece, it was also associated with sobriety (not being drunk or otherwise inebriated), but that usage has often been set aside in favour of its prime association with intuition.
The Norse runes have been around for millenia, as the earliest runic-style writings in caves date back to the late Bronze Age: around 1300 BC. This said, no one really truly knows how old they actually are, as it's been suggested that what we know as the runes were likely used as divinatory tools long before being used as an alphabetic system.
Norse/Teutonic mythology tells the story of how the runes came into being. Odin (aka Wodin/Woden/Wotan) is a Norse god who will do anything to gain more knowledge and wisdom. He envied the Norns their power to shape destiny with the runes, and thus he sought their wisdom. For those who are just coming to know the various mythologies beyond any classroom, the Norns are three women that might be considered the Scandinavian equivalent to the Greek Fates.
In the quest for the runic knowledge wielded by the Norns, Odin pierced himself, and hung upside down on the World Tree, known as Yggdrasil. He told no one to give him any kind of help, not even a drink of water, until he got the knowledge he sought. Finally, after nine days and nights, he was finally shown the powers of the runes, as they accepted his sacrifice. He was then able to do many things with this knowledge, including healing bodily and emotional wounds, binding enemies and making their weapons useless, and much more.
Now that you know the power of amethyst and the mystical essence of the runes, you can see why someone would have the insight to carve them into amethyst, and combine their energies. The amethyst heightens your intuitive knowledge, and you are using the runes that Odin himself learned while hanging on the World Tree, a very shamanic act, variations of which are echoed throughout many other stories, practises and rituals intended to bring about knowledge from Spirit.
Using amethyst runes, found in the Zen Spiritual shop, can bring an added dose of Otherworldly knowledge to your day in beautiful ways you might not expect. Simply be respectful of the knowledge you're given, as well as the stones themselves. Cleanse them, consecrate them as you see fit, and it's advisable not to let just anyone handle them.
Also, to create the proper energetic atmosphere for divination, make sure you're not going to be interrupted by phone calls, etc. It's also often suggested that you meditate beforehand, and you can create as simple or as elaborate a ceremony as you see fit, based on time, needs, etc.
While they're not the only divinatory tool in the world, the amethyst runes are a beautiful way to receive guidance for your life, as well as a way to help others, if you feel called to do so.


text:
Q: How to name the xs:elements in the generated wsdl? I fired up my WebServicesExplorer in my Eclipse recently and I just realized that the xs:element names generated by JAXB are not so verbose. Here is one of the sequences:
<xs:sequence>
  <xs:element minOccurs="0" name="arg0" type="xs:string" />
  <xs:element minOccurs="0" name="arg1" type="xs:string" />
  <xs:element name="arg2" type="xs:int" />
</xs:sequence>

generated from this file:
import javax.xml.bind.annotation.XmlRootElement;

@XmlRootElement
public class User {
    private String firstName;
    private String lastName;
    private int age;

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

I'm not a JAXB expert yet, so I was wondering whether I can change those arg* named elements into something sensible, like in the POJO class?

A: You do not mention what web service framework you are using but the behaviour sounds similar to the JAX-WS specs, e.g. The parts in my generated wsdl have names of the form "arg0", "arg1", ... Why don't the parts (and Java generated from them) use the nice parameter names I typed into the interface definition?

Official answer: The JAX-WS spec (specifically section 3.6.1) mandates that it be generated this way. To customize the name, you have to use an @WebParam(name = "blah") annotation to specify better names. (You can use @WebResult for the return value, but you'll only see the results if you look at the XML.)
Reason: One of the mysteries of java is that abstract methods (and thus interface methods) do NOT get their parameter names compiled into them even with debug info. Thus, when the service model is built from an interface, there is no way to determine the names that were using in the original code.
If the service is built from a concrete class (instead of an interface) AND the class was compiled with debug info, we can get the parameter names. The simple frontend does this. However, this could cause potential problems. For example, when you go from developement to production, you may turn off debug information (remove -g from javac flags) and suddenly the application may break since the generated wsdl (and thus expect soap messages) would change. Thus, the JAX-WS spec writers went the safe route and mandate that you have to use the @WebParam annotations to specify the more descriptive names.

You could try adding an XmlElement annotation to each field and specify a name, but are you sure this is caused by JAXB? If I run schemagen with your POJO code this is what I get (the names are picked up correctly):
<xs:complexType name="user">
    <xs:sequence>
      <xs:element name="age" type="xs:int"/>
      <xs:element name="firstName" type="xs:string" minOccurs="0"/>
      <xs:element name="lastName" type="xs:string" minOccurs="0"/>
    </xs:sequence>
</xs:complexType>

Based on your comment, if you "force" your POJO to the following code, do you still get complaints about duplicate names?
import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlAccessType;

@XmlAccessorType(XmlAccessType.NONE)
@XmlRootElement
public class User {
    @XmlElement(name = "firstName")
    private String firstName;

    @XmlElement(name = "lastName")
    private String lastName;

    @XmlElement(name = "age")
    private int age;

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }
}

redpajama_set_name: RedPajamaStackExchange


text:
Un robot laveur est un robot d'entretien des surfaces qui est capable de brosser avec un liquide détachant et d'aspirer les étendues à nettoyer en toute autonomie. Il combine les tâches d'un robot aspirateur avec celui d'un robot serpillière. Il existe des robots laveur de surfaces à usage professionnel ou domestique.

Notes et références

Annexe

Articles connexes
Scooba
Robot d'aide à la personne

Robot laveur
Robot domestique

redpajama_set_name: RedPajamaWikipedia


text:
How the U.S. Spreads Fake Vaping Fears, Part II
Michelle Minton • 08/13/2020
In a previous post, I described how, through the use of statistical hocus pocus, anti-vaping interest have exported the great American vape panic to nations around the world. But the misuse of survey data is far from the only rabbit those seeking to ban nicotine vapor products can pull out of their hat. In this post, I discuss another approach employed by anti-vaping activists, one that is arguably much more dangerous: morality.
In defiance of history, science, and human nature, governments around the world are warming up to the idea of prohibition. While maintaining easy access to combustible cigarettes, governments are increasingly considering policies to ban, tax, or heavily restrict non-combustible forms of nicotine. Such policies, among others, will keep smokers smoking and millions around the globe dying as a result.
There is little point in trying to prove that the harms associated with nicotine, as with any substance, depend largely on how it is used. This is just a fact, as true as the adage that "the dose making the poison." Certainly, nicotine can be poisonous if ingested in large enough quantities, but the same is true of water. Prescription pain killers can be dangerous if abused, but millions of people around the world use them all the time without becoming addicted or overdosing.
Nicotine is no different. Used in moderate quantities, nicotine is not particularly harmful and has actually been shown to be beneficial for a number of conditions. It is also not as addictive as some continue to insist (hence, why we don't see nicotine gum or patch "addicts"). But, like prescription opioids, caffeine, alcohol, Adderall, and less socially acceptable substances, there are ways to consume nicotine that are relatively safe and ways that are significantly harmful.
Unfortunately, the most popular means of nicotine consumption continues to be in its deadliest form: combustible tobacco cigarettes, which some researchers believe kill approximately half of those who maintain the habit over a lifetime. Even with myriad forms of nicotine replacement therapies available without a prescription and often at no cost, most of the nicotine users in the world continue to get that nicotine by smoking. But not everywhere. In a few nations, smoking is being displaced by safer forms of nicotine use. And where that is happening, we are already seeing the benefits in terms of population health.
Success Ignored
Snus, if you're not familiar, is a moist tobacco chew. While available in a number of countries, it has gained widespread popularity in Sweden, where it has been used since the 17th century. Beginning in the 1980s, as the dangers of smoking became more widely known, Swedes began switching en masse from smoking to snus use with approximately 21 percent of Swedish men classified as "current users" by 2016. On the other hand, just about 7 percent of the adult population in Sweden continues to smoke (with just 5 percent smoking daily). That means that Sweden has not only the lowest prevalence of smoking in Europe, but also the lowest rates of smoking-related diseases like lung cancer and mouth cancer. In contrast, the average smoking rate in the rest of the European Union which bans snus, remains at 26 percent.
Sweden is not alone in achieving real public health success by offering consumers a safer nicotine alternative. In Japan, declines in cigarette sales have quintupled since the introduction of Philip Morris International's IQOS around 2014. That is, while cigarette sales were declining an average of 2 percent per year between 2011 and 2015, they declined by a whopping 10 percent per year between 2015 and 2018.
Because IQOS heats tobacco without burning it, the vapor produced by the device contains far fewer harmful and carcinogenic compounds. Thus, while the exact risk is unknown, heated tobacco products are expected to carry significantly less risk than traditional smoking, a belief the U.S. Food and Drug Administration recently affirmed. Thus, as more Japanese adults switch from smoking to heated tobacco products, officials expect smoking-related illness to decline as well.
Similar effects have been observed in Great Britain and the United States, where the governments embrace or, at least, tolerate "e-cigarettes" as a safer alternative to smoking. Both countries have experienced accelerated declines in smoking that are greater than declines observed in nations, like Australia, that have banned or practically banned these products. In fact, in the United Kingdom, which actually promotes nicotine vapor products for smokers, smoking rates have declined an impressive 16 percent since 2006. In the European Union, where e-cigarettes are not as welcomed, smoking rates have only declined 6 percent over the same time period.
What Sweden, Great Britain, Japan, and the U.S., to a lesser extent, are doing is called harm reduction. This approach, while recognizing that safer alternatives to smoking may not be completely free of risk (nothing is), also acknowledges that attempting to force every adult to abstain entirely from nicotine use is both impossible and unethical. But, while we can't prevent nicotine use, we can encourage people to use it in ways that are less harmful.
This recognition of human nature and the limits of public health underlies the idea of harm reduction and has been widely embraced in almost every other realm of health policy. We offer clean needles to intravenous drug users in an effort to reduce the spread of disease, provide methadone to opioid addicts to prevent overdose and relapse, and educate youth about safe sex and the use of prophylactics to prevent unwanted pregnancy and sexually transmitted infections. Even requiring the use of helmets and seat belts to minimize injuries from auto accidents is a form of harm minimization. Public health professionals agree that harm reduction is more effective for public health than say, throwing drug addicts in jail, banning motorcycles and cars, or forbidding adolescents from having sex (good luck, with that). But not when it comes to nicotine.
Harm Reduction Denied
The success these nations have had in reducing smoking and smoking-related illness by allowing smokers access to less harmful alternatives is undeniable. Yet, denial is the path chosen by a growing number of powerful people around the world. Even while the evidence continues to show that nicotine without combustion eliminates most of the risk associated with smoking, the number of countries banning these alternative products continues to grow.
As discussed in Part 1 of this series, these bans are usually couched in the language of "reasonable restrictions" rather than outright prohibition. Australia disallows the sale of nicotine vapor products and may soon prevent their importation from abroad, but as Health Minister Greg Hunt is quick to point out, they aren't "banned." Consumers can still get nicotine by prescription. Of course, that requires them to find a doctor willing to write such a prescription, of which there are only eight on the entire content. Even if you manage to get that prescription, you then need to find a pharmacist authorized to import and sell that nicotine to you, which reportedly involves a significant amount of paperwork and hurdle jumping. It isn't clear how many have or would go through this licensing process.
In the United States and to a lesser degree the United Kingdom, not-quite prohibition measures have centered on restricting where nicotine vapor can be purchased, banning non-tobacco flavors, increasing prices through taxation, and setting a maximum on the amount of nicotine they can contain. While less restrictive than criminalizing the products, these policies produce many of the same unintended consequences as outright prohibitions.
In the U.K., for example, which banned menthol cigarettes as of last May, smokers looking for that minty sensation have turned to all manner of potentially dangerous DIY strategies. Even lighter restrictions, like San Francisco's ban on flavored e-cigarettes or Minnesota's high e-cigarette tax backfired, causing more people to smoke traditional cigarettes. And, of course, Australia's ban/not-ban on nicotine vapor has led to many Australians buying nicotine concentrate from overseas, a practice not likely to be stopped if the government closes the existing "loophole."
The Church of Tobacco Control
Those unfamiliar with the issue may wonder why more and more countries pursue restrictions on nicotine vapor products if the evidence for their benefits, and against prohibition, is so clear. The answer, regrettably, is that laws governing recreational substances are rarely based on evidence. More often than not, they are based on public opinion, which has even less to do with evidence.
Few of us have the academic background to comprehend scientific research and even those of us who have this background don't often have the time to read it if it isn't directly related to our work. Most simply absorb the prevailing narrative on scientific issues under debate. We believe what is repeated by the media, what our friends and family are saying, or trust the perspective of respected authority figures.
The individuals and groups comprising the tobacco control movement know this. They know that with enough time, money, and influence, they can craft whatever narrative they want even if it directly conflicts with the existing science. And, for decades, that is what they have set out to do.
People are, in general, resistant to public health initiatives aimed at controlling people's personal choices for their own good. But, as advocates learned from their fight against smoking, if the public can be persuaded that a choice poses risks, not just to the individual making it, but to those around him as well, they can bypass the tricky issue of civil liberties and enlist non-users to their cause.
That is what activists did on the issue of child welfare and secondhand smoke. As anti-tobacco lobbyist Anne Marie O'Keefe said in 1992, "attacks on individual smokers were doomed to fail," because, as she said, it kept the issue in the "civil rights, individual personal liberties arena, where we were going to lose the fight." But there were two issues that those supporting individual rights could not overcome, as long-time anti-smoking activist Stanton Glantz recognized: passive smoking (secondhand smoke) and kids. But it was always about stopping adults from smoking. As Glantz noted in a 1983 speech at the Second World Conference on Tobacco and Health, "the effects of involuntary smoking on the non-smokers, probably holds the key to controlling and reducing primary smoking." He was not wrong.
Government reports, biased studies, and public health advertisements, paid for by taxes collected on smokers, effectively convinced many in the public that smokers were not just hurting themselves, but an "act of aggression" against those around them.
Years of frightening headlines about secondhand smoke being dangerous, even more dangerous than smoking (though with no explanation as to how that could be possible) successfully scared non-smokers into legislating smokers to the margins of society. "Today, smokers huddle in doorways and excuse themselves from meetings," prominent anti-tobacco activist Simon Chapman gloated in 2002. But, despite the rhetoric, this effort had little to do with protecting nonsmokers from the potential risks of secondhand smoke.
By stigmatizing smokers themselves, portraying them as dirty, uneducated, and downright dangerous, anti-smokers hoped they could force smokers to "do the right thing for themselves." As Glantz wrote in 2000, "indoor air legislation reduces smoking because it undercuts the social support network for smoking by implicitly defining smoking as an antisocial act." Thus, when anti-tobacco advocates decided that e-cigarettes were just as bad as smoking, they simply copied and pasted their anti-smoking strategies onto this new product category to convince the public they were no different.
As with smoking before, anti-vaping activists have framed their opposition to e-cigarettes, not as an issue of personal choice, but as an effort to protect young people from the predatory tobacco industry. For most people, particularly those in government, the fear of being accused of putting big business over child welfare was enough to enlist them in the cause or, at least, silence skeptics.
But the debate over low-risk forms of nicotine was never really about children, bystanders, or even the risk the products might pose to users. Opposition to e-cigarettes stems from dogma, the ethos of tobacco control that holds that enjoyment of nicotine—regardless of harm—is an unacceptable sin. Sinners can be redeemed, but only through punishment, either by suffering the misery of trying to quit smoking cold turkey, enduring the drudgery and side effects of cessation medication, or should those methods fail, by getting sick and dying. This suffering is not just punishment, but also deterrent. The advent of nicotine products that are enjoyable and don't cause illness or death is an existential threat to the tobacco control doctrine.
So, those opposed to e-cigarettes on moral grounds have waged a messaging campaign—similar to Big Tobacco's efforts to downplay the risks of smoking—to ignore or silence any evidence or person that might challenge their narrative that e-cigarettes are a threat to public health. For many, the ends justify the means.
Not So Noble Lies
But not everyone bearing the Tobacco Control banner is a true believer. Some are motivated by the earthlier concerns like power, money, and prestige. Careers and entire organizations have been built off the billions that were dedicated to stopping the scourge of smoking—money threatened by products that might actually achieve this goal. Governments, too, have a lot to lose, including the significant revenue derived from the sale of traditional cigarettes, through taxes, sales-based payments made by tobacco companies, or outright ownership stakes in tobacco companies. Politicians enjoy an ongoing stream of donations from both tobacco and pharmaceutical companies, industries threatened by competition from products like e-cigarettes. And many others are simply too afraid or powerless to oppose the tobacco control orthodoxy, with its history of attacking, defunding, de-platforming, and excommunicating apostates.
That, in a long-winded nutshell, is why the anti-vaping panic that started in the U.S. has spread, like a virus, around the world. It is simply easier and more profitable for most people and groups involved to continue believing that nicotine, in any form, is bad and should be banned, no matter what the science says about how safe it might be or how many lives it could save. And these perverse incentives have allowed a small group of people and interests benefit at the expense of individual autonomy, public health, and science.
New Junk Food Ordinance: Another "Feel Good" California Law that Does No Good
By: Michelle Minton
California is a tough place to live. Ranked as the state with the nation's worst quality of life, Californians have the biggest debt-to-income ratio, suffer…
Anti-Nicotine Zealots Only Care about Science When it Says What They Want
Opponents of nicotine vapor products like to claim the scientific high ground. For years, they have asserted there isn't enough evidence on the long-term risks…
Trump's Drug Price Control Orders Are Bound to Backfire
By: Gregory Conko
At a White House gathering last Friday, President Trump announced four new executive orders intended to restrict the ways pharmaceutical companies set the price of…
Consumer Well-Being

redpajama_set_name: RedPajamaCommonCrawl


Whether you're looking for a breast collar with all the bells and whistles or a get-the-job done piece, our guide has an option to fit your need.
Why buy: The 2½-inch-wide, Y-front breast collar minimizes the appearance of movement, and the sturdy steel hardware is built to last.
Cool feature: Choose your preferred oil color and border tooling for a fully customized look.
More info: (888) 955-2955; teskeys.com.
Model: All-natural mohair breast collar.
Maker: 5 Star Equine Products.
Why buy: Made of 100-percent natural mohair, the woven breast collar is built to last, and the stainless-steel hardware won't rust.
Cool feature: The breast collar is available in natural or vegetable-oiled-dyed patterns and designs, so won't cause skin irritation.
More info: (870) 389-6328; 5starequineproducts.com.
Model: Felt-lined, 2-inch-wide breast collar.
Why buy: The 2-inch-wide webbing provides security, and the soft, ½-inch-thick liner maximizes comfort.
Cool features: It's available in four colors, plus has a fully adjustable center strap with a tie-down dee.
More info: (800) 533-3377; jefferspet.com.
Model: Tapered no-choke breast collar.
Why buy: The tapered, Y-shaped design ensures that the piece stays in place on your horse's chest and doesn't interfere with his neck.
Cool feature: It's available in walnut, dark antique, and regular-oil options.
More info: (800) 531-3600; circley.com.
When you think of breast collars, most often you think of a traditional, leather-type item. But there are many other materials to choose from that'll suit your riding purposes. Use our guide to learn more about non-leather options, and then go online to read "Breast-Collar Buff" on HorseandRider.com to increase your savvy.
Mohair is soft and pliable, in addition to being sturdily made. For a horse with sensitive skin, consider a dye-free mohair breast collar to avoid skin irritation or discomfort that sometimes accompanies synthetic materials.
Neoprene provides cushion that leather or mohair may not. It's a comfortable option for a horse that wears his breast collar all day in rough and hot terrain, such as while trail riding. Neoprene doesn't breathe as well as other materials, though.
Fleece is thick and moisture-absorbing. Similar to neoprene, it provides cushioning that leather and mohair may not. This is a solid option for a hard-working horse, but because it absorbs moisture so well, it'll require more meticulous care to keep it in usable shape. Because it tends to pick up debris, it might not be best for the trail.
Nylon and other synthetic breast collars serve their purpose at a lower price point. These options require more frequent replacement and close attention to damage, but are typically found in interesting colors and patterns, which allows you to mix up your look more often.


Introduced at NAMM 2012, Shure's latest addition to the microflex line is the MX150 lavalier microphone. This mic provides improved compatibility with wireless platforms and it's sub-miniature size makes it invaluable when you need discreet mic placement.
Available in TQG for wireless use and XLR wired mics (includes preamp).
The MX150 leverages the microflex platform for premium installations and delivers best-in-class Shure performance and superior RF immunity.


text:
package bingo.lang;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertNull;
import static org.junit.Assert.assertSame;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;

import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
import java.nio.CharBuffer;

import junit.framework.TestCase;

import org.junit.Assert;
import org.junit.Test;

import bingo.lang.testing.junit.ConcurrentTestCase;

/**
 * {@link TestCase} of {@link Strings}
 */
public class StringsTest extends ConcurrentTestCase {

	static final String	        FOO	                = "FOO";
	static final String	        BAR	                = "BAR";
	static final String	        foo	                = "foo";
	static final String	        bar	                = "bar";
	static final String	        foobar	            = "foobar";
	static final String	        FOOBAR	            = "FOOBAR";

	static final String	        WHITESPACE;
	static final String	        NON_WHITESPACE;
	static final String	        TRIMMABLE;
	static final String	        NON_TRIMMABLE;

	static final String[]	    ARRAY_LIST	        = { "foo", "bar", "baz" };
	static final String[]	    EMPTY_ARRAY_LIST	= {};
	static final String[]	    NULL_ARRAY_LIST	    = { null };
	static final Object[]	    NULL_TO_STRING_LIST	= { new Object() {
		                                                @Override
		                                                public String toString() {
			                                                return null;
		                                                }
	                                                } };
	static final String[]	    MIXED_ARRAY_LIST	= { null, "", "foo" };
	static final Object[]	    MIXED_TYPE_LIST	    = { "foo", Long.valueOf(2L) };

	static final String	        SEPARATOR	        = ",";
	static final char	        SEPARATOR_CHAR	    = ';';

	static final String	        TEXT_LIST	        = "foo,bar,baz";
	static final String	        TEXT_LIST_CHAR	    = "foo;bar;baz";
	static final String	        TEXT_LIST_NOSEP	    = "foobarbaz";

	static final String	        FOO_UNCAP	        = "foo";
	static final String	        FOO_CAP	            = "Foo";

	static final String	        SENTENCE_UNCAP	    = "foo bar baz";
	static final String	        SENTENCE_CAP	    = "Foo Bar Baz";

	/**
	 * Supplementary character U+20000 See http://java.sun.com/developer/technicalArticles/Intl/Supplementary/
	 */
	private static final String	CharU20000	        = "\uD840\uDC00";
	/**
	 * Supplementary character U+20001 See http://java.sun.com/developer/technicalArticles/Intl/Supplementary/
	 */
	private static final String	CharU20001	        = "\uD840\uDC01";

    /**
     * Incomplete supplementary character U+20000, high surrogate only.
     * See http://java.sun.com/developer/technicalArticles/Intl/Supplementary/
     */
    private static final String CharUSuppCharHigh = "\uDC00";

    /**
     * Incomplete supplementary character U+20000, low surrogate only.
     * See http://java.sun.com/developer/technicalArticles/Intl/Supplementary/
     */
    private static final String CharUSuppCharLow = "\uD840";

	private static final String BAZ = "baz";
	private static final String SENTENCE = "foo bar baz";

	static {
		String ws = "";
		String nws = "";
		String tr = "";
		String ntr = "";
		for (int i = 0; i < Character.MAX_VALUE; i++) {
			if (Character.isWhitespace((char) i)) {
				ws += String.valueOf((char) i);
				if (i > 32) {
					ntr += String.valueOf((char) i);
				}
			} else if (i < 40) {
				nws += String.valueOf((char) i);
			}
		}
		for (int i = 0; i <= 32; i++) {
			tr += String.valueOf((char) i);
		}
		WHITESPACE = ws;
		NON_WHITESPACE = nws;
		TRIMMABLE = tr;
		NON_TRIMMABLE = ntr;
	}

	@Test
	public void testEmptyConstant() {
		assertNotNull(Strings.EMPTY);
		assertEquals("", Strings.EMPTY);
	}

	@Test
	public void testConstructor() {
		new Strings();
		new SubStrings();

		Constructor<?>[] cons = Strings.class.getDeclaredConstructors();
		assertEquals(1, cons.length);
		assertEquals(true, Modifier.isProtected(cons[0].getModifiers()));
		assertEquals(true, Modifier.isPublic(Strings.class.getModifiers()));
		assertEquals(false, Modifier.isFinal(Strings.class.getModifiers()));
	}

	@Test
	public void testSafe() {
		assertNotNull(Strings.safe(null));
		assertNotNull(Strings.safe(""));
		assertEquals("", Strings.safe(""));
		assertEquals(" x", Strings.safe(" x"));
		assertEquals(" x ", Strings.safe(" x "));
	}

	@Test
	public void testCaseFunctions() {
		assertEquals(Strings.EMPTY, Strings.upperCase(null));
		assertEquals(Strings.EMPTY, Strings.lowerCase(null));

		assertEquals("upperCase(String) failed", "FOO TEST THING", Strings.upperCase("fOo test THING"));
		assertEquals("upperCase(empty-string) failed", "", Strings.upperCase(""));
		assertEquals("lowerCase(String) failed", "foo test thing", Strings.lowerCase("fOo test THING"));
		assertEquals("lowerCase(empty-string) failed", "", Strings.lowerCase(""));
	}

	@Test
	public void testReplace_StringStringString() {
		assertEquals(Strings.EMPTY, Strings.replace(null, null, null));
		assertEquals(Strings.EMPTY, Strings.replace(null, null, "any"));
		assertEquals(Strings.EMPTY, Strings.replace(null, "any", null));
		assertEquals(Strings.EMPTY, Strings.replace(null, "any", "any"));

		assertEquals("", Strings.replace("", null, null));
		assertEquals("", Strings.replace("", null, "any"));
		assertEquals("", Strings.replace("", "any", null));
		assertEquals("", Strings.replace("", "any", "any"));

		assertEquals("FOO", Strings.replace("FOO", "", "any"));
		assertEquals("FOO", Strings.replace("FOO", null, "any"));
		assertEquals("FOO", Strings.replace("FOO", "F", null));
		assertEquals("FOO", Strings.replace("FOO", null, null));

		assertEquals("", Strings.replace("foofoofoo", "foo", ""));
		assertEquals("barbarbar", Strings.replace("foofoofoo", "foo", "bar"));
		assertEquals("farfarfar", Strings.replace("foofoofoo", "oo", "ar"));
	}

	@Test
	public void testReplaceIgnoreCase_StringStringString() {
		assertEquals(Strings.EMPTY, Strings.replaceIgnoreCase(null, null, null));
		assertEquals(Strings.EMPTY, Strings.replaceIgnoreCase(null, null, "any"));
		assertEquals(Strings.EMPTY, Strings.replaceIgnoreCase(null, "any", null));
		assertEquals(Strings.EMPTY, Strings.replaceIgnoreCase(null, "any", "any"));

		assertEquals("", Strings.replaceIgnoreCase("", null, null));
		assertEquals("", Strings.replaceIgnoreCase("", null, "any"));
		assertEquals("", Strings.replaceIgnoreCase("", "any", null));
		assertEquals("", Strings.replaceIgnoreCase("", "any", "any"));

		assertEquals("FOO", Strings.replaceIgnoreCase("FOO", "", "any"));
		assertEquals("FOO", Strings.replaceIgnoreCase("FOO", null, "any"));
		assertEquals("FOO", Strings.replaceIgnoreCase("FOO", "F", null));
		assertEquals("FOO", Strings.replaceIgnoreCase("FOO", "f", null));
		assertEquals("FOO", Strings.replaceIgnoreCase("FOO", null, null));

		assertEquals("", Strings.replaceIgnoreCase("foofoofoo", "foo", ""));
		assertEquals("", Strings.replaceIgnoreCase("foofooFOo", "FOO", ""));
		assertEquals("", Strings.replaceIgnoreCase("fooFoofoo", "FoO", ""));
		assertEquals("barbarbar", Strings.replaceIgnoreCase("foofoofoo", "foo", "bar"));
		assertEquals("barbarbar", Strings.replaceIgnoreCase("foofooFOo", "fOo", "bar"));
		assertEquals("barbarbar", Strings.replaceIgnoreCase("fooFoofoo", "FOO", "bar"));
		assertEquals("farfarfar", Strings.replaceIgnoreCase("foofoofoo", "oo", "ar"));
		assertEquals("farfarfar", Strings.replaceIgnoreCase("foofoofOo", "oO", "ar"));
	}

	@Test
	public void testReplaceOnce_StringStringString() {
		assertEquals(Strings.EMPTY, Strings.replaceOnce(null, null, null));
		assertEquals(Strings.EMPTY, Strings.replaceOnce(null, null, "any"));
		assertEquals(Strings.EMPTY, Strings.replaceOnce(null, "any", null));
		assertEquals(Strings.EMPTY, Strings.replaceOnce(null, "any", "any"));

		assertEquals("", Strings.replaceOnce("", null, null));
		assertEquals("", Strings.replaceOnce("", null, "any"));
		assertEquals("", Strings.replaceOnce("", "any", null));
		assertEquals("", Strings.replaceOnce("", "any", "any"));

		assertEquals("FOO", Strings.replaceOnce("FOO", "", "any"));
		assertEquals("FOO", Strings.replaceOnce("FOO", null, "any"));
		assertEquals("FOO", Strings.replaceOnce("FOO", "F", null));
		assertEquals("FOO", Strings.replaceOnce("FOO", null, null));

		assertEquals("foofoo", Strings.replaceOnce("foofoofoo", "foo", ""));
	}

	@Test
	public void testIndexOfAnyBut_StringCharArray() {
		assertEquals(-1, Strings.indexOfAnyBut(null, (char[]) null));
		assertEquals(-1, Strings.indexOfAnyBut(null, new char[0]));
		assertEquals(-1, Strings.indexOfAnyBut(null, new char[] { 'a', 'b' }));

		assertEquals(-1, Strings.indexOfAnyBut("", (char[]) null));
		assertEquals(-1, Strings.indexOfAnyBut("", new char[0]));
		assertEquals(-1, Strings.indexOfAnyBut("", new char[] { 'a', 'b' }));

		assertEquals(-1, Strings.indexOfAnyBut("zzabyycdxx", (char[]) null));
		assertEquals(-1, Strings.indexOfAnyBut("zzabyycdxx", new char[0]));
		assertEquals(3, Strings.indexOfAnyBut("zzabyycdxx", new char[] { 'z', 'a' }));
		assertEquals(0, Strings.indexOfAnyBut("zzabyycdxx", new char[] { 'b', 'y' }));
		assertEquals(-1, Strings.indexOfAnyBut("aba", new char[] { 'a', 'b' }));
		assertEquals(0, Strings.indexOfAnyBut("aba", new char[] { 'z' }));

	}

	@Test
	public void testIndexOfAnyBut_StringCharArrayWithSupplementaryChars() {
		assertEquals(2, Strings.indexOfAnyBut(CharU20000 + CharU20001, CharU20000.toCharArray()));
		assertEquals(0, Strings.indexOfAnyBut(CharU20000 + CharU20001, CharU20001.toCharArray()));
		assertEquals(-1, Strings.indexOfAnyBut(CharU20000, CharU20000.toCharArray()));
		assertEquals(0, Strings.indexOfAnyBut(CharU20000, CharU20001.toCharArray()));
	}

	@Test
	public void testIndexOfAnyBut_StringString() {
		assertEquals(-1, Strings.indexOfAnyBut(null, (String) null));
		assertEquals(-1, Strings.indexOfAnyBut(null, ""));
		assertEquals(-1, Strings.indexOfAnyBut(null, "ab"));

		assertEquals(-1, Strings.indexOfAnyBut("", (String) null));
		assertEquals(-1, Strings.indexOfAnyBut("", ""));
		assertEquals(-1, Strings.indexOfAnyBut("", "ab"));

		assertEquals(-1, Strings.indexOfAnyBut("zzabyycdxx", (String) null));
		assertEquals(-1, Strings.indexOfAnyBut("zzabyycdxx", ""));
		assertEquals(3, Strings.indexOfAnyBut("zzabyycdxx", "za"));
		assertEquals(0, Strings.indexOfAnyBut("zzabyycdxx", "by"));
		assertEquals(0, Strings.indexOfAnyBut("ab", "z"));
	}

	@Test
	public void testIndexOfAnyBut_StringStringWithSupplementaryChars() {
		assertEquals(2, Strings.indexOfAnyBut(CharU20000 + CharU20001, CharU20000));
		assertEquals(0, Strings.indexOfAnyBut(CharU20000 + CharU20001, CharU20001));
		assertEquals(-1, Strings.indexOfAnyBut(CharU20000, CharU20000));
		assertEquals(0, Strings.indexOfAnyBut(CharU20000, CharU20001));
	}

	/**
	 * Test Strings.startsWith()
	 */
	@Test
	public void testStartsWith() {
		assertTrue("startsWith(null, null)", Strings.startsWith(null, (String) null));
		assertFalse("startsWith(FOOBAR, null)", Strings.startsWith(FOOBAR, (String) null));
		assertFalse("startsWith(null, FOO)", Strings.startsWith(null, FOO));
		assertTrue("startsWith(FOOBAR, \"\")", Strings.startsWith(FOOBAR, ""));

		assertTrue("startsWith(foobar, foo)", Strings.startsWith(foobar, foo));
		assertTrue("startsWith(FOOBAR, FOO)", Strings.startsWith(FOOBAR, FOO));
		assertFalse("startsWith(foobar, FOO)", Strings.startsWith(foobar, FOO));
		assertFalse("startsWith(FOOBAR, foo)", Strings.startsWith(FOOBAR, foo));

		assertFalse("startsWith(foo, foobar)", Strings.startsWith(foo, foobar));
		assertFalse("startsWith(foo, foobar)", Strings.startsWith(bar, foobar));

		assertFalse("startsWith(foobar, bar)", Strings.startsWith(foobar, bar));
		assertFalse("startsWith(FOOBAR, BAR)", Strings.startsWith(FOOBAR, BAR));
		assertFalse("startsWith(foobar, BAR)", Strings.startsWith(foobar, BAR));
		assertFalse("startsWith(FOOBAR, bar)", Strings.startsWith(FOOBAR, bar));
	}

	/**
	 * Test Strings.testStartsWithIgnoreCase()
	 */
	@Test
	public void testStartsWithIgnoreCase() {
		assertTrue("startsWithIgnoreCase(null, null)", Strings.startsWithIgnoreCase(null, (String) null));
		assertFalse("startsWithIgnoreCase(FOOBAR, null)", Strings.startsWithIgnoreCase(FOOBAR, (String) null));
		assertFalse("startsWithIgnoreCase(null, FOO)", Strings.startsWithIgnoreCase(null, FOO));
		assertTrue("startsWithIgnoreCase(FOOBAR, \"\")", Strings.startsWithIgnoreCase(FOOBAR, ""));

		assertTrue("startsWithIgnoreCase(foobar, foo)", Strings.startsWithIgnoreCase(foobar, foo));
		assertTrue("startsWithIgnoreCase(FOOBAR, FOO)", Strings.startsWithIgnoreCase(FOOBAR, FOO));
		assertTrue("startsWithIgnoreCase(foobar, FOO)", Strings.startsWithIgnoreCase(foobar, FOO));
		assertTrue("startsWithIgnoreCase(FOOBAR, foo)", Strings.startsWithIgnoreCase(FOOBAR, foo));

		assertFalse("startsWithIgnoreCase(foo, foobar)", Strings.startsWithIgnoreCase(foo, foobar));
		assertFalse("startsWithIgnoreCase(foo, foobar)", Strings.startsWithIgnoreCase(bar, foobar));

		assertFalse("startsWithIgnoreCase(foobar, bar)", Strings.startsWithIgnoreCase(foobar, bar));
		assertFalse("startsWithIgnoreCase(FOOBAR, BAR)", Strings.startsWithIgnoreCase(FOOBAR, BAR));
		assertFalse("startsWithIgnoreCase(foobar, BAR)", Strings.startsWithIgnoreCase(foobar, BAR));
		assertFalse("startsWithIgnoreCase(FOOBAR, bar)", Strings.startsWithIgnoreCase(FOOBAR, bar));
	}

	/**
	 * Test Strings.endsWith()
	 */
	@Test
	public void testEndsWith() {
		assertTrue("endsWith(null, null)", Strings.endsWith(null, (String) null));
		assertFalse("endsWith(FOOBAR, null)", Strings.endsWith(FOOBAR, (String) null));
		assertFalse("endsWith(null, FOO)", Strings.endsWith(null, FOO));
		assertTrue("endsWith(FOOBAR, \"\")", Strings.endsWith(FOOBAR, ""));

		assertFalse("endsWith(foobar, foo)", Strings.endsWith(foobar, foo));
		assertFalse("endsWith(FOOBAR, FOO)", Strings.endsWith(FOOBAR, FOO));
		assertFalse("endsWith(foobar, FOO)", Strings.endsWith(foobar, FOO));
		assertFalse("endsWith(FOOBAR, foo)", Strings.endsWith(FOOBAR, foo));

		assertFalse("endsWith(foo, foobar)", Strings.endsWith(foo, foobar));
		assertFalse("endsWith(foo, foobar)", Strings.endsWith(bar, foobar));

		assertTrue("endsWith(foobar, bar)", Strings.endsWith(foobar, bar));
		assertTrue("endsWith(FOOBAR, BAR)", Strings.endsWith(FOOBAR, BAR));
		assertFalse("endsWith(foobar, BAR)", Strings.endsWith(foobar, BAR));
		assertFalse("endsWith(FOOBAR, bar)", Strings.endsWith(FOOBAR, bar));
	}

	/**
	 * Test Strings.endsWithIgnoreCase()
	 */
	@Test
	public void testEndsWithIgnoreCase() {
		assertTrue("endsWithIgnoreCase(null, null)", Strings.endsWithIgnoreCase(null, (String) null));
		assertFalse("endsWithIgnoreCase(FOOBAR, null)", Strings.endsWithIgnoreCase(FOOBAR, (String) null));
		assertFalse("endsWithIgnoreCase(null, FOO)", Strings.endsWithIgnoreCase(null, FOO));
		assertTrue("endsWithIgnoreCase(FOOBAR, \"\")", Strings.endsWithIgnoreCase(FOOBAR, ""));

		assertFalse("endsWithIgnoreCase(foobar, foo)", Strings.endsWithIgnoreCase(foobar, foo));
		assertFalse("endsWithIgnoreCase(FOOBAR, FOO)", Strings.endsWithIgnoreCase(FOOBAR, FOO));
		assertFalse("endsWithIgnoreCase(foobar, FOO)", Strings.endsWithIgnoreCase(foobar, FOO));
		assertFalse("endsWithIgnoreCase(FOOBAR, foo)", Strings.endsWithIgnoreCase(FOOBAR, foo));

		assertFalse("endsWithIgnoreCase(foo, foobar)", Strings.endsWithIgnoreCase(foo, foobar));
		assertFalse("endsWithIgnoreCase(foo, foobar)", Strings.endsWithIgnoreCase(bar, foobar));

		assertTrue("endsWithIgnoreCase(foobar, bar)", Strings.endsWithIgnoreCase(foobar, bar));
		assertTrue("endsWithIgnoreCase(FOOBAR, BAR)", Strings.endsWithIgnoreCase(FOOBAR, BAR));
		assertTrue("endsWithIgnoreCase(foobar, BAR)", Strings.endsWithIgnoreCase(foobar, BAR));
		assertTrue("endsWithIgnoreCase(FOOBAR, bar)", Strings.endsWithIgnoreCase(FOOBAR, bar));

		// javadoc
		assertTrue(Strings.endsWithIgnoreCase("abcdef", "def"));
		assertTrue(Strings.endsWithIgnoreCase("ABCDEF", "def"));
		assertFalse(Strings.endsWithIgnoreCase("ABCDEF", "cde"));
	}

	@Test
	public void testRemoveStart() {
		// Strings.removeStart("", *)        = ""
		assertEquals("", Strings.removeStart(null, null));
		assertEquals("", Strings.removeStart(null, ""));
		assertEquals("", Strings.removeStart(null, "a"));

		// Strings.removeStartsWith(*, null)      = *
		assertEquals(Strings.removeStart("", null), "");
		assertEquals(Strings.removeStart("", ""), "");
		assertEquals(Strings.removeStart("", "a"), "");

		// All others:
		assertEquals(Strings.removeStart("www.domain.com", "www."), "domain.com");
		assertEquals(Strings.removeStart("domain.com", "www."), "domain.com");
		assertEquals(Strings.removeStart("domain.com", ""), "domain.com");
		assertEquals(Strings.removeStart("domain.com", null), "domain.com");
	}

	@Test
	public void testremoveStartsWithIgnoreCase() {
		// Strings.removeStartsWith("", *)        = ""
		assertEquals("", Strings.removeStartIgnoreCase(null, null));
		assertEquals("", Strings.removeStartIgnoreCase(null, ""));
		assertEquals("", Strings.removeStartIgnoreCase(null, "a"));

		// Strings.removeStartsWith(*, null)      = *
		assertEquals("removeStartsWithIgnoreCase(\"\", null)", Strings.removeStartIgnoreCase("", null), "");
		assertEquals("removeStartsWithIgnoreCase(\"\", \"\")", Strings.removeStartIgnoreCase("", ""), "");
		assertEquals("removeStartsWithIgnoreCase(\"\", \"a\")", Strings.removeStartIgnoreCase("", "a"), "");

		// All others:
		assertEquals("removeStartsWithIgnoreCase(\"www.domain.com\", \"www.\")", Strings.removeStartIgnoreCase("www.domain.com", "www."),
		        "domain.com");
		assertEquals("removeStartsWithIgnoreCase(\"domain.com\", \"www.\")", Strings.removeStartIgnoreCase("domain.com", "www."), "domain.com");
		assertEquals("removeStartsWithIgnoreCase(\"domain.com\", \"\")", Strings.removeStartIgnoreCase("domain.com", ""), "domain.com");
		assertEquals("removeStartsWithIgnoreCase(\"domain.com\", null)", Strings.removeStartIgnoreCase("domain.com", null), "domain.com");

		// Case insensitive:
		assertEquals("removeStartsWithIgnoreCase(\"www.domain.com\", \"WWW.\")", Strings.removeStartIgnoreCase("www.domain.com", "WWW."),
		        "domain.com");
	}

	@Test
	public void testRemoveEnd() {
		// Strings.removeEnd("", *)        = ""
		assertEquals("", Strings.removeEnd(null, null));
		assertEquals("", Strings.removeEnd(null, ""));
		assertEquals("", Strings.removeEnd(null, "a"));

		// Strings.removeEndsWith(*, null)      = *
		assertEquals(Strings.removeEnd("", null), "");
		assertEquals(Strings.removeEnd("", ""), "");
		assertEquals(Strings.removeEnd("", "a"), "");

		// All others:
		assertEquals(Strings.removeEnd("www.domain.com.", ".com"), "www.domain.com.");
		assertEquals(Strings.removeEnd("www.domain.com", ".com"), "www.domain");
		assertEquals(Strings.removeEnd("www.domain", ".com"), "www.domain");
		assertEquals(Strings.removeEnd("domain.com", ""), "domain.com");
		assertEquals(Strings.removeEnd("domain.com", null), "domain.com");
	}

	@Test
	public void testremoveEndsWithIgnoreCase() {
		// Strings.removeEndsWithIgnoreCase("", *)        = ""
		assertEquals("", Strings.removeEndIgnoreCase(null, null));
		assertEquals("", Strings.removeEndIgnoreCase(null, ""));
		assertEquals("", Strings.removeEndIgnoreCase(null, "a"));

		// Strings.removeEndsWith(*, null)      = *
		assertEquals("removeEndsWithIgnoreCase(\"\", null)", Strings.removeEndIgnoreCase("", null), "");
		assertEquals("removeEndsWithIgnoreCase(\"\", \"\")", Strings.removeEndIgnoreCase("", ""), "");
		assertEquals("removeEndsWithIgnoreCase(\"\", \"a\")", Strings.removeEndIgnoreCase("", "a"), "");

		// All others:
		assertEquals("removeEndsWithIgnoreCase(\"www.domain.com.\", \".com\")", Strings.removeEndIgnoreCase("www.domain.com.", ".com"),
		        "www.domain.com.");
		assertEquals("removeEndsWithIgnoreCase(\"www.domain.com\", \".com\")", Strings.removeEndIgnoreCase("www.domain.com", ".com"),
		        "www.domain");
		assertEquals("removeEndsWithIgnoreCase(\"www.domain\", \".com\")", Strings.removeEndIgnoreCase("www.domain", ".com"), "www.domain");
		assertEquals("removeEndsWithIgnoreCase(\"domain.com\", \"\")", Strings.removeEndIgnoreCase("domain.com", ""), "domain.com");
		assertEquals("removeEndsWithIgnoreCase(\"domain.com\", null)", Strings.removeEndIgnoreCase("domain.com", null), "domain.com");

		// Case insensitive:
		assertEquals("removeEndsWithIgnoreCase(\"www.domain.com\", \".COM\")", Strings.removeEndIgnoreCase("www.domain.com", ".COM"),
		        "www.domain");
		assertEquals("removeEndsWithIgnoreCase(\"www.domain.COM\", \".com\")", Strings.removeEndIgnoreCase("www.domain.COM", ".com"),
		        "www.domain");
	}

	@Test
	public void testRemove_String() {
		// Strings.remove(null, *)        = null
		assertEquals("", Strings.remove(null, null));
		assertEquals("", Strings.remove(null, ""));
		assertEquals("", Strings.remove(null, "a"));

		// Strings.remove("", *)          = ""
		assertEquals("", Strings.remove("", null));
		assertEquals("", Strings.remove("", ""));
		assertEquals("", Strings.remove("", "a"));

		// Strings.remove(*, null)        = *
		assertEquals("", Strings.remove(null, null));
		assertEquals("", Strings.remove("", null));
		assertEquals("a", Strings.remove("a", null));

		// Strings.remove(*, "")          = *
		assertEquals("", Strings.remove(null, ""));
		assertEquals("", Strings.remove("", ""));
		assertEquals("a", Strings.remove("a", ""));

		// Strings.remove("queued", "ue") = "qd"
		assertEquals("qd", Strings.remove("queued", "ue"));

		// Strings.remove("queued", "zz") = "queued"
		assertEquals("queued", Strings.remove("queued", "zz"));
	}

	@Test
	public void testRemove_char() {
		// Strings.remove(null, *)       = null
		assertEquals("", Strings.remove(null, 'a'));

		// Strings.remove("", *)          = ""
		assertEquals("", Strings.remove("", 'a'));
		assertEquals("", Strings.remove("", 'a'));
		assertEquals("", Strings.remove("", 'a'));

		// Strings.remove("queued", 'u') = "qeed"
		assertEquals("qeed", Strings.remove("queued", 'u'));

		// Strings.remove("queued", 'z') = "queued"
		assertEquals("queued", Strings.remove("queued", 'z'));
	}

	@Test
	public void testRepeat_StringInt() {
		assertEquals("", Strings.repeat(null, 2));
		assertEquals("", Strings.repeat("ab", 0));
		assertEquals("", Strings.repeat("", 3));
		assertEquals("aaa", Strings.repeat("a", 3));
		assertEquals("ababab", Strings.repeat("ab", 3));
		assertEquals("abcabcabc", Strings.repeat("abc", 3));
		String str = Strings.repeat("a", 10000); // bigger than pad limit
		assertEquals(10000, str.length());
		assertTrue(Strings.containsOnly(str, new char[] { 'a' }));
	}

	@Test
	public void testRepeat_StringStringInt() {
		assertEquals("", Strings.repeat(null, null, 2));
		assertEquals("", Strings.repeat(null, "x", 2));
		assertEquals("", Strings.repeat("", null, 2));

		assertEquals("", Strings.repeat("ab", "", 0));
		assertEquals("", Strings.repeat("", "", 2));

		assertEquals("xx", Strings.repeat("", "x", 3));

		assertEquals("?, ?, ?", Strings.repeat("?", ", ", 3));
	}

	@Test
	public void testRightPad_StringInt() {
		assertEquals("", Strings.padRight(null, 5));
		assertEquals("     ", Strings.padRight("", 5));
		assertEquals("abc  ", Strings.padRight("abc", 5));
		assertEquals("abc", Strings.padRight("abc", 2));
		assertEquals("abc", Strings.padRight("abc", -1));
	}

	@Test
	public void testpaddingRight_StringIntChar() {
		assertEquals("", Strings.padRight(null, ' ', 5));
		assertEquals("     ", Strings.padRight("", ' ', 5));
		assertEquals("abc  ", Strings.padRight("abc", ' ', 5));
		assertEquals("abc", Strings.padRight("abc", ' ', 2));
		assertEquals("abc", Strings.padRight("abc", ' ', -1));
		assertEquals("abcxx", Strings.padRight("abc", 'x', 5));
		String str = Strings.padRight("aaa", 'a', 10000); // bigger than pad length
		assertEquals(10000, str.length());
		assertTrue(Strings.containsOnly(str, new char[] { 'a' }));
	}

	@Test
	public void testpaddingRight_StringIntString() {
		assertEquals("", Strings.padRight(null, "-+", 5));
		assertEquals("     ", Strings.padRight("", " ", 5));
		assertEquals("", Strings.padRight(null, null, 8));
		assertEquals("abc-+-+", Strings.padRight("abc", "-+", 7));
		assertEquals("abc-+~", Strings.padRight("abc", "-+~", 6));
		assertEquals("abc-+", Strings.padRight("abc", "-+~", 5));
		assertEquals("abc", Strings.padRight("abc", " ", 2));
		assertEquals("abc", Strings.padRight("abc", " ", -1));
		assertEquals("abc  ", Strings.padRight("abc", null, 5));
		assertEquals("abc  ", Strings.padRight("abc", "", 5));
	}

	//-----------------------------------------------------------------------
	@Test
	public void testLeftPad_StringInt() {
		assertEquals("", Strings.padLeft(null, 5));
		assertEquals("     ", Strings.padLeft("", 5));
		assertEquals("  abc", Strings.padLeft("abc", 5));
		assertEquals("abc", Strings.padLeft("abc", 2));
	}

	@Test
	public void testpaddingLeft_StringIntChar() {
		assertEquals("", Strings.padLeft(null, ' ', 5));
		assertEquals("     ", Strings.padLeft("", ' ', 5));
		assertEquals("  abc", Strings.padLeft("abc", ' ', 5));
		assertEquals("xxabc", Strings.padLeft("abc",'x', 5));
		assertEquals("\uffff\uffffabc", Strings.padLeft("abc",  '\uffff', 5));
		assertEquals("abc", Strings.padLeft("abc", ' ', 2));
		String str = Strings.padLeft("aaa", 'a', 10000); // bigger than pad length
		assertEquals(10000, str.length());
		assertTrue(Strings.containsOnly(str, new char[] { 'a' }));
	}

	@Test
	public void testpaddingLeft_StringIntString() {
		assertEquals("", Strings.padLeft(null, "-+", 5));
		assertEquals("", Strings.padLeft(null, null, 5));
		assertEquals("     ", Strings.padLeft("", " ", 5));
		assertEquals("-+-+abc", Strings.padLeft("abc", "-+", 7));
		assertEquals("-+~abc", Strings.padLeft("abc", "-+~", 6));
		assertEquals("-+abc", Strings.padLeft("abc", "-+~", 5));
		assertEquals("abc", Strings.padLeft("abc", " ", 2));
		assertEquals("abc", Strings.padLeft("abc", " ", -1));
		assertEquals("  abc", Strings.padLeft("abc", null, 5));
		assertEquals("  abc", Strings.padLeft("abc", "", 5));
	}

	@Test
	public void testLengthString() {
		assertEquals(0, Strings.length(null));
		assertEquals(0, Strings.length(""));
		assertEquals(0, Strings.length(Strings.EMPTY));
		assertEquals(1, Strings.length("A"));
		assertEquals(1, Strings.length(" "));
		assertEquals(8, Strings.length("ABCDEFGH"));
	}

	@Test
	public void testLengthStringBuffer() {
		assertEquals(0, Strings.length(new StringBuffer("")));
		assertEquals(0, Strings.length(new StringBuffer(Strings.EMPTY)));
		assertEquals(1, Strings.length(new StringBuffer("A")));
		assertEquals(1, Strings.length(new StringBuffer(" ")));
		assertEquals(8, Strings.length(new StringBuffer("ABCDEFGH")));
	}

	@Test
	public void testLengthStringBuilder() {
		assertEquals(0, Strings.length(new StringBuilder("")));
		assertEquals(0, Strings.length(new StringBuilder(Strings.EMPTY)));
		assertEquals(1, Strings.length(new StringBuilder("A")));
		assertEquals(1, Strings.length(new StringBuilder(" ")));
		assertEquals(8, Strings.length(new StringBuilder("ABCDEFGH")));
	}

	@Test
	public void testLength_CharBuffer() {
		assertEquals(0, Strings.length(CharBuffer.wrap("")));
		assertEquals(1, Strings.length(CharBuffer.wrap("A")));
		assertEquals(1, Strings.length(CharBuffer.wrap(" ")));
		assertEquals(8, Strings.length(CharBuffer.wrap("ABCDEFGH")));
	}

	@Test
    public void testSubstring_StringInt() {
        assertEquals("", Strings.substring(null, 0));
        assertEquals("", Strings.substring("", 0));

        try {
	        assertEquals("", Strings.substring("", 2));
	        Assert.fail("IndexOutOfBoundsException should have been thrown");
        } catch (IndexOutOfBoundsException e) {
        }

        assertEquals(BAZ, Strings.substring(SENTENCE, 8));
        assertEquals(SENTENCE, Strings.substring(SENTENCE, 0));

        try {
        	assertEquals("abc", Strings.substring("abc", -4));
	        Assert.fail("IndexOutOfBoundsException should have been thrown");
        } catch (IndexOutOfBoundsException e) {
        }

        assertEquals("abc", Strings.substring("abc", 0));
        assertEquals("bc", Strings.substring("abc", 1));
        assertEquals("c", Strings.substring("abc", 2));
        assertEquals("", Strings.substring("abc", 3));
    }

	@Test
    public void testSubstring_StringIntInt() {
        assertEquals("", Strings.substring((String)null, 0, 0));
        assertEquals("", Strings.substring((String)null, 1, 2));
        assertEquals("", Strings.substring("", 0, 0));

        try {
        	assertEquals("", Strings.substring("", 1, 2));
	        Assert.fail("IndexOutOfBoundsException should have been thrown");
        } catch (IndexOutOfBoundsException e) {
        }

        try {
        	assertEquals("", Strings.substring("", -2, -1));
	        Assert.fail("IndexOutOfBoundsException should have been thrown");
        } catch (IndexOutOfBoundsException e) {
        }

        try {
        	assertEquals("", Strings.substring(SENTENCE, 8, 6));
	        Assert.fail("IndexOutOfBoundsException should have been thrown");
        } catch (IndexOutOfBoundsException e) {
        }

        assertEquals(foo, Strings.substring(SENTENCE, 0, 3));
        assertEquals("", Strings.substring(SENTENCE, 2, 2));
    }

    @Test
    public void testSubstringChars() {
        char[] buffer = " name:  value    ".toCharArray();

        Assert.assertEquals(" name", Strings.substring(buffer,0, 5));
        Assert.assertEquals("  value    ", Strings.substring(buffer,6,buffer.length));
        Assert.assertEquals("name", Strings.substringTrimmed(buffer,0, 5));
        Assert.assertEquals("value", Strings.substringTrimmed(buffer, 6, buffer.length));
        Assert.assertEquals("", Strings.substringTrimmed(buffer, 13, buffer.length));
    }

    @Test
    public void testSubstringCharsIndexOfOutBound() {
        char[] buffer = "stuff".toCharArray();
        try {
            Strings.substring(buffer,-2, 10);
            Assert.fail("IndexOutOfBoundsException should have been thrown");
        } catch (IndexOutOfBoundsException ex) {
            // expected
        }
        try {
        	Strings.substringTrimmed(buffer,-2, 10);
            Assert.fail("IndexOutOfBoundsException should have been thrown");
        } catch (IndexOutOfBoundsException ex) {
            // expected
        }
        try {
        	Strings.substring(buffer,12, 10);
            Assert.fail("IndexOutOfBoundsException should have been thrown");
        } catch (IndexOutOfBoundsException ex) {
            // expected
        }
        try {
        	Strings.substringTrimmed(buffer,12, 10);
            Assert.fail("IndexOutOfBoundsException should have been thrown");
        } catch (IndexOutOfBoundsException ex) {
            // expected
        }
        try {
        	Strings.substring(buffer,2, 1);
            Assert.fail("IndexOutOfBoundsException should have been thrown");
        } catch (IndexOutOfBoundsException ex) {
            // expected
        }
        try {
        	Strings.substringTrimmed(buffer,2, 1);
            Assert.fail("IndexOutOfBoundsException should have been thrown");
        } catch (IndexOutOfBoundsException ex) {
            // expected
        }
    }

	@Test
    public void testLeft_String() {
        assertSame("", Strings.left(null, -1));
        assertSame("", Strings.left(null, 0));
        assertSame("", Strings.left(null, 2));

        assertEquals("", Strings.left("", -1));
        assertEquals("", Strings.left("", 0));
        assertEquals("", Strings.left("", 2));

        assertEquals("", Strings.left(FOOBAR, -1));
        assertEquals("", Strings.left(FOOBAR, 0));
        assertEquals(FOO, Strings.left(FOOBAR, 3));
        assertSame(FOOBAR, Strings.left(FOOBAR, 80));
    }

	@Test
    public void testRight_String() {
        assertSame("", Strings.right(null, -1));
        assertSame("", Strings.right(null, 0));
        assertSame("", Strings.right(null, 2));

        assertEquals("", Strings.right("", -1));
        assertEquals("", Strings.right("", 0));
        assertEquals("", Strings.right("", 2));

        assertEquals("", Strings.right(FOOBAR, -1));
        assertEquals("", Strings.right(FOOBAR, 0));
        assertEquals(BAR, Strings.right(FOOBAR, 3));
        assertSame(FOOBAR, Strings.right(FOOBAR, 80));
    }

	@Test
    public void testContains_Char() {
        assertEquals(false, Strings.contains(null, ' '));
        assertEquals(false, Strings.contains("", ' '));
        assertEquals(false, Strings.contains("", null));
        assertEquals(false, Strings.contains(null, null));
        assertEquals(true, Strings.contains("abc", 'a'));
        assertEquals(true, Strings.contains("abc", 'b'));
        assertEquals(true, Strings.contains("abc", 'c'));
        assertEquals(false, Strings.contains("abc", 'z'));
    }

	@Test
    public void testContains_String() {
        assertEquals(false, Strings.contains(null, null));
        assertEquals(false, Strings.contains(null, ""));
        assertEquals(false, Strings.contains(null, "a"));
        assertEquals(false, Strings.contains("", null));
        assertEquals(true, Strings.contains("", ""));
        assertEquals(false, Strings.contains("", "a"));
        assertEquals(true, Strings.contains("abc", "a"));
        assertEquals(true, Strings.contains("abc", "b"));
        assertEquals(true, Strings.contains("abc", "c"));
        assertEquals(true, Strings.contains("abc", "abc"));
        assertEquals(false, Strings.contains("abc", "z"));
    }

    /**
     * See http://java.sun.com/developer/technicalArticles/Intl/Supplementary/
     */
	@Test
    public void testContains_StringWithBadSupplementaryChars() {
        // Test edge case: 1/2 of a (broken) supplementary char
        assertEquals(false, Strings.contains(CharUSuppCharHigh, CharU20001));
        assertEquals(false, Strings.contains(CharUSuppCharLow, CharU20001));
        assertEquals(false, Strings.contains(CharU20001, CharUSuppCharHigh));
        assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
        assertEquals(true, Strings.contains(CharU20001, CharUSuppCharLow));
        assertEquals(true, Strings.contains(CharU20001 + CharUSuppCharLow + "a", "a"));
        assertEquals(true, Strings.contains(CharU20001 + CharUSuppCharHigh + "a", "a"));
    }

    /**
     * See http://java.sun.com/developer/technicalArticles/Intl/Supplementary/
     */
	@Test
    public void testContains_StringWithSupplementaryChars() {
        assertEquals(true, Strings.contains(CharU20000 + CharU20001, CharU20000));
        assertEquals(true, Strings.contains(CharU20000 + CharU20001, CharU20001));
        assertEquals(true, Strings.contains(CharU20000, CharU20000));
        assertEquals(false, Strings.contains(CharU20000, CharU20001));
    }

	@Test
    public void testContainsIgnoreCase_StringString() {
        assertFalse(Strings.containsIgnoreCase(null, null));

        // Null tests
        assertFalse(Strings.containsIgnoreCase(null, ""));
        assertFalse(Strings.containsIgnoreCase(null, "a"));
        assertFalse(Strings.containsIgnoreCase(null, "abc"));

        assertFalse(Strings.containsIgnoreCase("", null));
        assertFalse(Strings.containsIgnoreCase("a", null));
        assertFalse(Strings.containsIgnoreCase("abc", null));

        // Match len = 0
        assertTrue(Strings.containsIgnoreCase("", ""));
        assertTrue(Strings.containsIgnoreCase("a", ""));
        assertTrue(Strings.containsIgnoreCase("abc", ""));

        // Match len = 1
        assertFalse(Strings.containsIgnoreCase("", "a"));
        assertTrue(Strings.containsIgnoreCase("a", "a"));
        assertTrue(Strings.containsIgnoreCase("abc", "a"));
        assertFalse(Strings.containsIgnoreCase("", "A"));
        assertTrue(Strings.containsIgnoreCase("a", "A"));
        assertTrue(Strings.containsIgnoreCase("abc", "A"));

        // Match len > 1
        assertFalse(Strings.containsIgnoreCase("", "abc"));
        assertFalse(Strings.containsIgnoreCase("a", "abc"));
        assertTrue(Strings.containsIgnoreCase("xabcz", "abc"));
        assertFalse(Strings.containsIgnoreCase("", "ABC"));
        assertFalse(Strings.containsIgnoreCase("a", "ABC"));
        assertTrue(Strings.containsIgnoreCase("xabcz", "ABC"));
    }

	@Test
    public void testContainsNone_CharArray() {
        String str1 = "a";
        String str2 = "b";
        String str3 = "ab.";
        char[] chars1= {'b'};
        char[] chars2= {'.'};
        char[] chars3= {'c', 'd'};
        char[] emptyChars = new char[0];
        assertEquals(true, Strings.containsNone(null, (char[]) null));
        assertEquals(true, Strings.containsNone("", (char[]) null));
        assertEquals(true, Strings.containsNone(null, emptyChars));
        assertEquals(true, Strings.containsNone(str1, emptyChars));
        assertEquals(true, Strings.containsNone("", emptyChars));
        assertEquals(true, Strings.containsNone("", chars1));
        assertEquals(true, Strings.containsNone(str1, chars1));
        assertEquals(true, Strings.containsNone(str1, chars2));
        assertEquals(true, Strings.containsNone(str1, chars3));
        assertEquals(false, Strings.containsNone(str2, chars1));
        assertEquals(true, Strings.containsNone(str2, chars2));
        assertEquals(true, Strings.containsNone(str2, chars3));
        assertEquals(false, Strings.containsNone(str3, chars1));
        assertEquals(false, Strings.containsNone(str3, chars2));
        assertEquals(true, Strings.containsNone(str3, chars3));
    }

    /**
     * See http://java.sun.com/developer/technicalArticles/Intl/Supplementary/
     */
	@Test
    public void testContainsNone_CharArrayWithBadSupplementaryChars() {
        // Test edge case: 1/2 of a (broken) supplementary char
        assertEquals(true, Strings.containsNone(CharUSuppCharHigh, CharU20001.toCharArray()));
        assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
        assertEquals(true, Strings.containsNone(CharUSuppCharLow, CharU20001.toCharArray()));
        assertEquals(-1, CharU20001.indexOf(CharUSuppCharHigh));
        assertEquals(true, Strings.containsNone(CharU20001, CharUSuppCharHigh.toCharArray()));
        assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
        assertEquals(false, Strings.containsNone(CharU20001, CharUSuppCharLow.toCharArray()));
    }

    /**
     * See http://java.sun.com/developer/technicalArticles/Intl/Supplementary/
     */
	@Test
    public void testContainsNone_CharArrayWithSupplementaryChars() {
        assertEquals(false, Strings.containsNone(CharU20000 + CharU20001, CharU20000.toCharArray()));
        assertEquals(false, Strings.containsNone(CharU20000 + CharU20001, CharU20001.toCharArray()));
        assertEquals(false, Strings.containsNone(CharU20000, CharU20000.toCharArray()));
        // Sanity check:
        assertEquals(-1, CharU20000.indexOf(CharU20001));
        assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
        assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
        // Test:
        assertEquals(true, Strings.containsNone(CharU20000, CharU20001.toCharArray()));
        assertEquals(true, Strings.containsNone(CharU20001, CharU20000.toCharArray()));
    }

	@Test
    public void testContainsNone_String() {
        String str1 = "a";
        String str2 = "b";
        String str3 = "ab.";
        String chars1= "b";
        String chars2= ".";
        String chars3= "cd";
        assertEquals(true, Strings.containsNone(null, (String) null));
        assertEquals(true, Strings.containsNone("", (String) null));
        assertEquals(true, Strings.containsNone(null, ""));
        assertEquals(true, Strings.containsNone(str1, ""));
        assertEquals(true, Strings.containsNone("", ""));
        assertEquals(true, Strings.containsNone("", chars1));
        assertEquals(true, Strings.containsNone(str1, chars1));
        assertEquals(true, Strings.containsNone(str1, chars2));
        assertEquals(true, Strings.containsNone(str1, chars3));
        assertEquals(false, Strings.containsNone(str2, chars1));
        assertEquals(true, Strings.containsNone(str2, chars2));
        assertEquals(true, Strings.containsNone(str2, chars3));
        assertEquals(false, Strings.containsNone(str3, chars1));
        assertEquals(false, Strings.containsNone(str3, chars2));
        assertEquals(true, Strings.containsNone(str3, chars3));
    }

    /**
     * See http://java.sun.com/developer/technicalArticles/Intl/Supplementary/
     */
	@Test
    public void testContainsNone_StringWithBadSupplementaryChars() {
        // Test edge case: 1/2 of a (broken) supplementary char
        assertEquals(true, Strings.containsNone(CharUSuppCharHigh, CharU20001));
        assertEquals(-1, CharUSuppCharLow.indexOf(CharU20001));
        assertEquals(true, Strings.containsNone(CharUSuppCharLow, CharU20001));
        assertEquals(-1, CharU20001.indexOf(CharUSuppCharHigh));
        assertEquals(true, Strings.containsNone(CharU20001, CharUSuppCharHigh));
        assertEquals(0, CharU20001.indexOf(CharUSuppCharLow));
        assertEquals(false, Strings.containsNone(CharU20001, CharUSuppCharLow));
    }

    /**
     * See http://java.sun.com/developer/technicalArticles/Intl/Supplementary/
     */
	@Test
    public void testContainsNone_StringWithSupplementaryChars() {
        assertEquals(false, Strings.containsNone(CharU20000 + CharU20001, CharU20000));
        assertEquals(false, Strings.containsNone(CharU20000 + CharU20001, CharU20001));
        assertEquals(false, Strings.containsNone(CharU20000, CharU20000));
        // Sanity check:
        assertEquals(-1, CharU20000.indexOf(CharU20001));
        assertEquals(0, CharU20000.indexOf(CharU20001.charAt(0)));
        assertEquals(-1, CharU20000.indexOf(CharU20001.charAt(1)));
        // Test:
        assertEquals(true, Strings.containsNone(CharU20000, CharU20001));
        assertEquals(true, Strings.containsNone(CharU20001, CharU20000));
    }

	@Test
    public void testContainsOnly_CharArray() {
        String str1 = "a";
        String str2 = "b";
        String str3 = "ab";
        char[] chars1= {'b'};
        char[] chars2= {'a'};
        char[] chars3= {'a', 'b'};
        char[] emptyChars = new char[0];
        assertEquals(false, Strings.containsOnly(null, (char[]) null));
        assertEquals(false, Strings.containsOnly("", (char[]) null));
        assertEquals(false, Strings.containsOnly(null, emptyChars));
        assertEquals(false, Strings.containsOnly(str1, emptyChars));
        assertEquals(true, Strings.containsOnly("", emptyChars));
        assertEquals(true, Strings.containsOnly("", chars1));
        assertEquals(false, Strings.containsOnly(str1, chars1));
        assertEquals(true, Strings.containsOnly(str1, chars2));
        assertEquals(true, Strings.containsOnly(str1, chars3));
        assertEquals(true, Strings.containsOnly(str2, chars1));
        assertEquals(false, Strings.containsOnly(str2, chars2));
        assertEquals(true, Strings.containsOnly(str2, chars3));
        assertEquals(false, Strings.containsOnly(str3, chars1));
        assertEquals(false, Strings.containsOnly(str3, chars2));
        assertEquals(true, Strings.containsOnly(str3, chars3));
    }

	@Test
    public void testContainsOnly_String() {
        String str1 = "a";
        String str2 = "b";
        String str3 = "ab";
        String chars1= "b";
        String chars2= "a";
        String chars3= "ab";
        assertEquals(false, Strings.containsOnly(null, (String) null));
        assertEquals(false, Strings.containsOnly("", (String) null));
        assertEquals(false, Strings.containsOnly(null, ""));
        assertEquals(false, Strings.containsOnly(str1, ""));
        assertEquals(true, Strings.containsOnly("", ""));
        assertEquals(true, Strings.containsOnly("", chars1));
        assertEquals(false, Strings.containsOnly(str1, chars1));
        assertEquals(true, Strings.containsOnly(str1, chars2));
        assertEquals(true, Strings.containsOnly(str1, chars3));
        assertEquals(true, Strings.containsOnly(str2, chars1));
        assertEquals(false, Strings.containsOnly(str2, chars2));
        assertEquals(true, Strings.containsOnly(str2, chars3));
        assertEquals(false, Strings.containsOnly(str3, chars1));
        assertEquals(false, Strings.containsOnly(str3, chars2));
        assertEquals(true, Strings.containsOnly(str3, chars3));
    }

	@Test
    public void testContainsWhitespace() {
        assertFalse( Strings.containsWhitespace("") );
        assertTrue( Strings.containsWhitespace(" ") );
        assertFalse( Strings.containsWhitespace("a") );
        assertTrue( Strings.containsWhitespace("a ") );
        assertTrue( Strings.containsWhitespace(" a") );
        assertTrue( Strings.containsWhitespace("a\t") );
        assertTrue( Strings.containsWhitespace("\n") );
    }

	@Test
    public void testCountOccurrences_String() {
        assertEquals(0, Strings.countOccurrences(null, null));
        assertEquals(0, Strings.countOccurrences("blah", null));
        assertEquals(0, Strings.countOccurrences(null, "DD"));

        assertEquals(0, Strings.countOccurrences("x", ""));
        assertEquals(0, Strings.countOccurrences("", ""));

        assertEquals(3,
             Strings.countOccurrences("one long someone sentence of one", "one"));
        assertEquals(0,
             Strings.countOccurrences("one long someone sentence of one", "two"));
        assertEquals(4,
             Strings.countOccurrences("oooooooooooo", "ooo"));
    }

	@Test
    public void testTrimToNull_Object(){
    	assertNull(Strings.trimToNull("   "));
    	assertNotNull(Strings.trimToNull("1   "));
    	assertNotNull(Strings.trimToNull("   1"));
    	assertNotNull(Strings.trimToNull("  1  "));
    	assertNull(Strings.trimToNull(""));
    	assertEquals("123", Strings.trimToNull("   123   "));
    }

    //-----------------------------------------------------------------------
    @Test
    public void testAbbreviate_StringInt() {
        assertEquals(null, Strings.abbreviate(null, 10));
        assertEquals("", Strings.abbreviate("", 10));
        assertEquals("short", Strings.abbreviate("short", 10));
        assertEquals("Now is ...", Strings.abbreviate("Now is the time for all good men to come to the aid of their party.", 10));

        String raspberry = "raspberry peach";
        assertEquals("raspberry p...", Strings.abbreviate(raspberry, 14));
        assertEquals("raspberry peach", Strings.abbreviate("raspberry peach", 15));
        assertEquals("raspberry peach", Strings.abbreviate("raspberry peach", 16));
        assertEquals("abc...", Strings.abbreviate("abcdefg", 6));
        assertEquals("abcdefg", Strings.abbreviate("abcdefg", 7));
        assertEquals("abcdefg", Strings.abbreviate("abcdefg", 8));
        assertEquals("a...", Strings.abbreviate("abcdefg", 4));
        assertEquals("", Strings.abbreviate("", 4));

        try {
            @SuppressWarnings("unused")
            String res = Strings.abbreviate("abc", 3);
            fail("Strings.abbreviate expecting IllegalArgumentException");
        } catch (IllegalArgumentException ex) {
                // empty
        }
    }

    @Test
    public void testAbbreviate_StringIntInt() {
        assertEquals(null, Strings.abbreviate(null, 10, 12));
        assertEquals("", Strings.abbreviate("", 0, 10));
        assertEquals("", Strings.abbreviate("", 2, 10));

        try {
            @SuppressWarnings("unused")
            String res = Strings.abbreviate("abcdefghij", 0, 3);
            fail("Strings.abbreviate expecting IllegalArgumentException");
        } catch (IllegalArgumentException ex) {
                // empty
        }
        try {
            @SuppressWarnings("unused")
            String res = Strings.abbreviate("abcdefghij", 5, 6);
            fail("Strings.abbreviate expecting IllegalArgumentException");
        } catch (IllegalArgumentException ex) {
                // empty
        }

        String raspberry = "raspberry peach";
        assertEquals("raspberry peach", Strings.abbreviate(raspberry, 11, 15));

        assertEquals(null, Strings.abbreviate(null, 7, 14));
        assertAbbreviateWithOffset("abcdefg...", -1, 10);
        assertAbbreviateWithOffset("abcdefg...", 0, 10);
        assertAbbreviateWithOffset("abcdefg...", 1, 10);
        assertAbbreviateWithOffset("abcdefg...", 2, 10);
        assertAbbreviateWithOffset("abcdefg...", 3, 10);
        assertAbbreviateWithOffset("abcdefg...", 4, 10);
        assertAbbreviateWithOffset("...fghi...", 5, 10);
        assertAbbreviateWithOffset("...ghij...", 6, 10);
        assertAbbreviateWithOffset("...hijk...", 7, 10);
        assertAbbreviateWithOffset("...ijklmno", 8, 10);
        assertAbbreviateWithOffset("...ijklmno", 9, 10);
        assertAbbreviateWithOffset("...ijklmno", 10, 10);
        assertAbbreviateWithOffset("...ijklmno", 10, 10);
        assertAbbreviateWithOffset("...ijklmno", 11, 10);
        assertAbbreviateWithOffset("...ijklmno", 12, 10);
        assertAbbreviateWithOffset("...ijklmno", 13, 10);
        assertAbbreviateWithOffset("...ijklmno", 14, 10);
        assertAbbreviateWithOffset("...ijklmno", 15, 10);
        assertAbbreviateWithOffset("...ijklmno", 16, 10);
        assertAbbreviateWithOffset("...ijklmno", Integer.MAX_VALUE, 10);
    }

    private void assertAbbreviateWithOffset(String expected, int offset, int maxWidth) {
        String abcdefghijklmno = "abcdefghijklmno";
        String message = "abbreviate(String,int,int) failed";
        String actual = Strings.abbreviate(abcdefghijklmno, offset, maxWidth);
        if (offset >= 0 && offset < abcdefghijklmno.length()) {
            assertTrue(message + " -- should contain offset character",
                    actual.indexOf((char)('a'+offset)) != -1);
        }
        assertTrue(message + " -- should not be greater than maxWidth",
                actual.length() <= maxWidth);
        assertEquals(message, expected, actual);
    }

    @Test
    public void testAbbreviateMiddle() {
        // javadoc examples
        assertNull( Strings.abbreviateMiddle(null, null, 0) );
        assertEquals( "abc", Strings.abbreviateMiddle("abc", null, 0) );
        assertEquals( "abc", Strings.abbreviateMiddle("abc", ".", 0) );
        assertEquals( "abc", Strings.abbreviateMiddle("abc", ".", 3) );
        assertEquals( "ab.f", Strings.abbreviateMiddle("abcdef", ".", 4) );
        assertEquals("ab...j",Strings.abbreviateMiddle("abcdefghij", "...", 6));

        // JIRA issue (LANG-405) example (slightly different than actual expected result)
        assertEquals(
            "A very long text with un...f the text is complete.",
            Strings.abbreviateMiddle(
                "A very long text with unimportant stuff in the middle but interesting start and " +
                "end to see if the text is complete.", "...", 50) );

        // Test a much longer text :)
        String longText = "Start text" + Strings.repeat("x", 10000) + "Close text";
        assertEquals(
            "Start text->Close text",
            Strings.abbreviateMiddle( longText, "->", 22 ) );

        // Test negative length
        assertEquals("abc", Strings.abbreviateMiddle("abc", ".", -1));

        // Test boundaries
        // Fails to change anything as method ensures first and last char are kept
        assertEquals("abc", Strings.abbreviateMiddle("abc", ".", 1));
        assertEquals("abc", Strings.abbreviateMiddle("abc", ".", 2));

        // Test length of n=1
        assertEquals("a", Strings.abbreviateMiddle("a", ".", 1));

        // Test smallest length that can lead to success
        assertEquals("a.d", Strings.abbreviateMiddle("abcd", ".", 3));

        // More from LANG-405
        assertEquals("a..f", Strings.abbreviateMiddle("abcdef", "..", 4));
        assertEquals("ab.ef", Strings.abbreviateMiddle("abcdef", ".", 5));
    }

    @Test
    public void testLowerCamel(){
    	assertEquals("", Strings.lowerCamel(null, '_'));
    	assertEquals("", Strings.lowerCamel("", '_'));
    	assertEquals("helloWorld", Strings.lowerCamel("hello_world", '_'));
    	assertEquals("helloWorld", Strings.lowerCamel("hello_World", '_'));
    	assertEquals("helloWorld", Strings.lowerCamel("Hello_World", '_'));
    	assertEquals("helloWorld", Strings.lowerCamel("HeLlo_WOrld", '_'));
    	assertEquals("aaBbCc", Strings.lowerCamel("aa_bb_cc", '_'));
    }

    @Test
    public void testUpperCamel(){
    	assertEquals("", Strings.upperCamel(null, '_'));
    	assertEquals("", Strings.upperCamel("", '_'));
    	assertEquals("HelloWorld", Strings.upperCamel("hello_world", '_'));
    	assertEquals("HelloWorld", Strings.upperCamel("hello_World", '_'));
    	assertEquals("HelloWorld", Strings.upperCamel("Hello_World", '_'));
    	assertEquals("HelloWorld", Strings.upperCamel("HeLlo_WOrld", '_'));
    	assertEquals("AaBbCc", Strings.upperCamel("aa_bb_cc", '_'));
    }

	private static class SubStrings extends Strings {
		public SubStrings() {
			super();
		}
	}
}

redpajama_set_name: RedPajamaGithub


St. Joseph's College will adopt Canvas as its new Learning Management System (LMS) just over a year from now. As of Summer 2017, Canvas will be used within both online and on-ground venues.
The advantages of this LMS were not universally shared, as the Faculty Technology Committee reported earlier in the semester. After a successful pilot of Canvas during the last academic year, however, many instructors found that it offers a wide variety of new features and, in particular, that it has real potential to enhance student engagement.
Although the primary consideration in vetting LMS systems was quality and enhancement of the student experience, we should say that cost was a secondary factor: Canvas will save the College approximately $60,000 per year, which is not an insignificant sum.
out on May 2, 2016, and continue until full implementation. The College's current Learning Management System, Blackboard, will continue to be available until June 30, 2017.