Last Friday I was invited to visit the Upstate New York Eating Disorder Service (The Nutrition Clinic) in Elmira, NY. Accompanied by Mary Ellen Clausen, the founder of Ophelia's Place, we drove the 2 hours to Elmira on a chilly upstate morning, chatting the whole way about life, business, and all things Syracuse. The time with Mary Ellen was reason enough to take the trip-she shared many of her experiences running Ophelia's Place and Cafe at 407, and as I am just 6 months into running Syracuse Yoga with still so much to learn, I took in every word. Mary Ellen is a wonderful soul with great advice. I am lucky to know her, and Syracuse is so lucky that she has made Ophelia's Place her life's work.
I am a HUGE fan of Ophelia's Place, Cafe at 407, and Circles of Change. I am a proud Movement Warrior, having taken the pledge to change the conversation and culture around body image, health and beauty. I truly believe Yoga is for Everybody and EveryBODY. The work done at Ophelia's Place changes lives, and no one is turned away if they need help. Want to learn more? You can take the Circles of Change pledge here and learn more about Ophelia's Place here.
Eating disorders and disordered eating are prevalent in the fitness community (and really every community). To better serve my Syracuse Yoga community, I wanted to learn more about how Ophelia's Place helps people. Mary Ellen invited me to Elmira to meet Carolyn Hodges Chaffee, MSRDN, CEDRD, who opened The Nutrition Clinic over two decades ago. Recognizing the need for more intensive treatment and regional step-down programs, she also opened the Sol Stone Center, a partial hospitalization program in Elmira, and added intensive outpatient programs in Syracuse (the partnership with Ophelia's Place), Ithaca, and Binghamton. The Upstate New York Eating Disorder Service now serves more than 400 patients a year.
Carolyn conducts state-of-the-art metabolic testing and body composition analysis to evaluate the nutritional status of each individual. This helps guide treatment recommendations, and the testing helps assess how individuals respond to treatment.
I went through the metabolic testing and the body composition analysis-both tests took under 30 minutes to complete. What I learned about my own health and wellness was eye opening.
Here I am promoting self care to others through Yoga, partnering with students on their Yoga journeys, and I found out I am taking in about 1000 less calories a day than I should, causing my body to be catabolic and hypometabolic. What does that mean? From the internet: A catabolic state is a condition that is mainly caused by excessive training coupled with a lack of adequate nutrition, especially protein. It results in numerous undesirable side effects in the body, such as extreme fatigue, joint and muscle pain, and sleeplessness. Read about being hypometabolic here. Also, I was about half a liter low on fluids. So not only am I not eating enough, I am also not drinking enough water. Yikes. Unconscious disordered eating. I didn't mean to have this happen to me, but it happened.
I've been so busy running Syracuse Yoga and teaching upwards of 20 Yoga classes a week that I haven't been practicing enough self care. I'm not talking I haven't had enough bubble baths or facials (although more of those would be great!). Sadly, I haven't had enough fuel. Food. Nourishment. Now I get why I've been so tired all the time, or there are days when my muscles ache in an unfamiliar way, and those restless nights of sleep, and the irritability/brain fog. I see why my doctor keeps ordering thyroid tests. I get it now. I first felt embarrassed. I mean, I am a scientist, the daughter of a chef. I should know how to eat, right? How can I take care of others when I am not taking care of myself?
We develop bad habits-eating on the run, grabbing whatever is available. Meal time for me has dwindled to a 5 min shoveling session-get it in quick because there is too much to do! There's no time, things have to get done! I feel compelled to share this experience with you all, mainly because I think I'm not alone. This culture of busy, this putting ourselves last. Maybe you do it too? This working so hard I "forgot to eat lunch" thing. It's not a badge of honor to eat less.
The part that really hits home for me is how connected my nutrition is to my overall wellness. Without the right fuel, or enough fuel, a bad cycle starts to form. 95% of our seratonin is in the gut. If you don't ingest the right fuel, seratonin drops, affecting mood. There is an effect on your immune system too-if you don't have the right fuel and your body starts to get run down, that's when you get sick. Menstrual Cycles can be affected. Maybe you are stuck in this cycle too.
This metabolic testing was so eye opening for me, and I see how beneficial it is for people that have eating disorders/disordered eating. Once diagnosed and treatment begins, these tests can help determine if the patient's health is improving. Here's the thing-most of the time we can't tell on the outside if people have an eating disorder. People may look totally healthy, or even what we might call overweight by society's standards, or totally fit with abs of steel, or thin...these tests show what is on the inside, and this information is so valuable for overall wellness.
Knowledge is power. Now that I know what is happening in my body, it's time to take action. Food prep on the weekends is critical for me to ensure I have food to eat on busy days at the studio. Planning meals ahead of time and grocery shopping have to become non negotiables on my to do list. I have been given permission to eat more (the data supports it!), which is a totally foreign concept for me.
Now that I have done the initial testing, I can make an appointment periodically at Ophelia's Place to do follow up body composition testing to see if I am improving or not.
Want to support Ophelia's Place? Help them reach their year end goal with a donation. Every little bit helps. I donated this morning!
Thank you again to Mary Ellen Clausen and Ophelia's Place. You gave me the greatest gift this holiday season-the gift of awareness and health. I will be forever grateful and will continue to support Ophelia's Place and Cafe at 407 as a Warrior of Change!!!


nicolebarr.com - Nicole Barr Enamel Jewelry, Cufflinks in 18K Gold, Silver. Buy your - Sterling Silver Green Dragonfly Brooch-Pendant. Peridot. White Sapphires. on nicolbarr.com.
Sterling Silver Green Dragonfly Brooch-Pendant. Peridot. White Sapphires.
Plique-a-Jour Enamel Sterling Silver Green Dragonfly Brooch-Pendant. Peridot. Set with White Sapphires. Rhodium Plated for easy care. Gift Boxed.


The following figures give the Tests for Congruent Triangles: SSS, SAS, AAS, SAS, RHS. Scroll down the page for more examples and solutions.
This video looks at triangle congruency. How one triangle is an exact copy of another in terms of its sides and angles.
The five tests (SSS, SAS, AAS, SAS, RHS) to show that one triangle is congruent to another are each explained. The special case of right-angled triangle congruency is dealt with in some detail, using Geogebra constructions.
Three worked solutions to congruency problems are explained.
How to derive the rules?


The University of California and the California Community Colleges today (April 11) announced they have signed a joint agreement aimed at increasing the number of academically prepared community college students who transfer to UC and earn a bachelor's degree.
UC President Janet Napolitano and CCC Chancellor Eloy Ortiz Oakley signed the memorandum of understanding, "Enhancing Student Transfer," that immediately initiates a comprehensive effort to guarantee admission for all qualifying California Community College transfer students to the University of California's system of nine undergraduate campuses.
Existing transfer admission guarantees, known as TAGs, negotiated between a student and an individual campus, will be retained. Where the California Community College Associate Degree for Transfer meets or exceeds the major requirements in a UC transfer pathway for the same major — as determined by the UC Academic Senate in consultation with the California Community Colleges Academic Senate — it will be accepted in lieu of a pathway for purposes of the guarantee.
The MOU details several areas where UC and the community colleges will work together to ensure that the agreement meets the goals it has set forth, including efforts to expand the number of associate degrees that would also satisfy UC major preparation requirements. Key to this is the commitment of the joint leadership to work together to identify and secure the necessary resources. The MOU may be accessed here.


text:
What if the angry white man is a woman? The gender gap in voting for the populist radical right
The archetypal populist radical right voter is usually thought of as being male, with female voters less likely to back these parties in elections. But many of these parties have nevertheless drawn on a substantial share of support from women. Outlining results from a recent study, Niels Spierings writes that although there is a gender gap in support for populist radical right parties, focusing on their female supporters can provide a more nuanced understanding of their success.
With the Brexit referendum, the election of Trump, and major general elections in The Netherlands, France and Germany taking place in 2017, the European spotlight is once again on the populist radical right. And attention is also being focused on the people voting for populist radical right parties – particularly the men voting for these parties, as it is often stressed that they are Männerparteien. It was women who were credited with keeping the FPÖ's Norbert Hofer from the Austrian presidency and if it had been up to their American counterparts Clinton would have been elected.
But the idea that populist radical right parties classify as Männerparteien is a partial truth at best: without women's votes, Trump would not have been president and Geert Wilders would have only received about 8% instead of 13% of the vote in the most recent Dutch elections. The US and the Netherlands are far from exceptions in this sense.
In a recent study based on 2014 European Social Survey data across nine European countries we found that populist radical right parties draw considerably less votes from women than non-populist parties, but across the board between 40 to 45% of the vote for populist radical right parties still comes from women (see below). Similarly, in an earlier study of 2010 data we found that in each and every country, populist radical right parties had the highest or second highest male-female vote ratio; however, in the seven countries studied 40 to 45% of the votes for these parties still came from women.
Figure 1: Female and Male vote shares in Austria, Denmark, Finland, France, Germany, Greece, Italy, The Netherlands, and Spain based on 2014 ESS data
Note: For more information, see the author's recent article in West European Politics
Why men and women vote for the populist radical right
The most pertinent questions about this gender gap are not about the gap itself, but rather the broader issue of understanding why people vote for these parties. The gender gap is a piece of that larger puzzle and by focusing on it the overly-simplistic idea of their success being rooted in the support of 'angry white men' can be unpacked, which is necessary for understanding why people, both men and women, do and do not vote for populist radical right parties.
Several explanations have been suggested to explain why women vote less often for these parties. Most studies find it is not linked to anti-migration stances, which clearly feed into voting for populist radical right parties, as women do not seem to be more compassionate or less anti-migration. What does make a difference is that women are less likely to work in manual labour or as small business owners. These groups tend to vote more frequently for populist radical right parties given the economic threat they experience from globalisation and economic liberalisation.
Economic and programmatic attitudes, however, focus only on one half of the ideology – the radical right – while they pay little attention to the populist part of the equation. Populism, in short, juxtaposes an intrinsically 'good' people against a corrupt elite. It is a worldview with an antagonistic core. As such, populism itself might be gendered as in European societies women tend to be socialised towards consensus-seeking behaviour and less aggressive communication: into being less receptive to populism.
Women are not less populist – except when they are
For the countries mentioned above, we tapped into populist attitudes by focusing on the distance between politics and the perceptions of men and women. More concretely, we combined survey items that measure political trust and efficacy, the idea that politicians care about what people think. And on these items, average women do not differ from average men – at first glance, at any rate. If we zoom in a little, the analysis shows that women are actually less likely to be strongly 'populist': 8% of the men and 6% of the women score 8 or higher on a ten-point scale.
For the Netherlands, more recent and precise indicators of populist attitudes are available in the SKON election study on the 2016 Ukraine treaty referendum. This survey asks, for instance, to what extent people think that political differences are larger between the elite and the people than among the people. Again, there is little difference between the mean populist score for women and men. But, also again, men turn out to be overrepresented at the extremes (see Figure 2): 19.3% of the men score 7.5 and up on a scale of 10; while only 14.6% of the women do.
Figure 2: Distribution of populist attitudes among men and women in the Netherlands 2016 based on SKON data
Note: More information can be derived from the author
Moreover, and most importantly, in our comparative study on the different European countries, we see that this worldview is a strong explanatory factor for who votes for populist radical right parties, and this is another piece of the puzzle explaining the gender gap in voting choices. Women and men might thus have roughly similar programmatic attitudes, but hold somewhat different views on conceptualising politics. Women seem on average to think less in terms of conflicting extremes or to appreciate these stances less. Consequently, populist radical right stances and forms of communication seem to appeal somewhat less to them.
Why the gender gap matters
If mainstream parties want to win back the voters that have switched to the populist radical right and 'defeat populism', the solution is not just moving toward the radical right, as for instance Cas Mudde has also argued in relation to the recent Dutch elections. Analyses of voter surveys indicate that a fair share of the story is that numerous people have become more populist: they think that the political elite does not represent them and is corrupt, with individuals acting against the will of the perceived homogenous people. This may be at the core of the anger many voters feel.
In itself, this general conclusion on why voters back the populist radical right is not new and it offers only a diagnosis, not a solution. But the gender lens applied in our study might help on that front. Angry white women exist, but in smaller numbers than angry white men. Therefore, a considerable number of these men must have wives and mothers who have not yet conceptualised politics as the evil they perceive it as. Mainstream politicians could reach out to these women in the 'grey zone' particularly, making them feel represented and pulling them back from the populist radical right. And with them, perhaps, also the men in their lives.
This post is based on the recent research article in West European Politics by Niels Spierings and Andrej Zaslove
Please read our comments policy before commenting.
Note: This article gives the views of the author, and not the position of EUROPP – European Politics and Policy, nor of the London School of Economics.
Niels Spierings – Radboud University
Niels Spierings is Assistant Professor at Radboud University. He works on issues of inequality and participation, particularly in relation to gender, politics, and Islam.
Posted In: featured | Latest Research | Politics
Book Review: Dark Academia: How Universities Die by Peter Fleming
Book Review: Corporate Citizen: New Perspectives on the Globalized Rule of Law edited by Oonagh E. Fitzgerald
Regulating COVID-19: What lessons can be learned from the handling of the 2009 swine flu pandemic by the EU and the WHO?
Explaining the uneven demand for EU parliamentary oversight during the Eurozone crisis

redpajama_set_name: RedPajamaCommonCrawl


text:
Home > Research > Publications & Outputs > A Game-Based Approximate Verification of Deep N...
A Game-Based Approximate Verification of Deep Neural Networks with Provable Guarantees
Rights statement: This is the author's version of a work that was accepted for publication in Theoretical Computer Science. Changes resulting from the publishing process, such as peer review, editing, corrections, structural formatting, and other quality control mechanisms may not be reflected in this document. Changes may have been made to this work since it was submitted for publication. A definitive version was subsequently published in Theoretical Computer Science, 807, 2019 DOI: 10.1016/j.tcs.2019.05.046
Accepted author manuscript, 6.16 MB, PDF document
Available under license: CC BY-NC-ND: Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International License
https://doi.org/10.1016/j.tcs.2019.05.046
Min Wu
Matthew Wicker
Wenjie Ruan
Xiaowei Huang
Marta Kwiatkowska
Despite the improved accuracy of deep neural networks, the discovery of adversarial examples has raised serious safety concerns. In this paper, we study two variants of pointwise robustness, the maximum safe radius problem, which for a given input sample computes the minimum distance to an adversarial example, and the feature robustness problem, which aims to quantify the robustness of individual features to adversarial perturbations. We demonstrate that, under the assumption of Lipschitz continuity, both problems can be approximated using finite optimisation by discretising the input space, and the approximation has provable guarantees, i.e., the error is bounded. We then show that the resulting optimisation problems can be reduced to the solution of two-player turn-based games, where the first player selects features and the second perturbs the image within the feature. While the second player aims to minimise
the distance to an adversarial example, depending on the optimisation objective the first player can be cooperative or competitive. We employ an anytime
approach to solve the games, in the sense of approximating the value of a game
by monotonically improving its upper and lower bounds. The Monte Carlo tree
search algorithm is applied to compute upper bounds for both games, and the
Admissible A* and the Alpha-Beta Pruning algorithms are, respectively, used
to compute lower bounds for the maximum safety radius and feature robustness
games. When working on the upper bound of the maximum safe radius problem, our tool demonstrates competitive performance against existing adversarial
example crafting algorithms. Furthermore, we show how our framework can be
deployed to evaluate pointwise robustness of neural networks in safety-critical
applications such as traffic sign recognition in self-driving cars.
Bibliographic note
This is the author's version of a work that was accepted for publication in Theoretical Computer Science. Changes resulting from the publishing process, such as peer review, editing, corrections, structural formatting, and other quality control mechanisms may not be reflected in this document. Changes may have been made to this work since it was submitted for publication. A definitive version was subsequently published in Theoretical Computer Science, 807, 2019 DOI: 10.1016/j.tcs.2019.05.046


What's to be done when the radar simply does not see the rain? It happened again in Houston, Texas on March 27th – and those relying on radars were flying blind. But anyone using ClimaCell's next-gen technologies saw something in the weather that wasn't detected by radar or other traditional sources. While we watched, ClimaCell's live HD weather map lit up with surface-level rain, showing a low level moist layer producing widespread showers and drizzle that eventually moved from the gulf coast up to Houston Intercontinental Airport. In the GIF above, our microwave links showed a significant area of precipitation approaching from the south.
A major weather company that presented images from a conventional radar product was not able to see the rain, as pictured below.
We keep seeing how airlines benefit the most when they use multiple sources of weather information to make the best operational decisions. Moreover, by adding new technologies like ClimaCell's to their decision-making process, a once-muddled picture of the weather comes into HD focus.


Gourmet Girl Gail here writing from windy Santa Barbara. Did you know that April 12 is Grilled Cheese Sandwich Day? Yep! It has its own unofficial holiday, celebrating one of the most popular comfort foods on the planet. In a ranking of America's favorite cheesy foods, pizza ranks #1 (94% of Americans claim to love them), followed by grilled cheese sandwiches (87%), macaroni & cheese (87%), and cheeseburgers (82%).
This Philly Voice article points out five establishments where Philadelphians can find some delicious melted goodness on Friday. And I thought Philadelphia was only known for its Philly cheesesteaks, a long, crusty roll filled with thinly sliced sautéed rib-eye beef and melted cheese. Not true!
Maybe you're planning on being creative and making your own grilled cheese wonderment come Friday! If so, the Gourmet Girls Go Camping Cookbook has an awesome recipe for a gourmet grilled cheese.
A few weeks ago, I was asked by Los Padres ForestWatch to lead a team in their first time competing at the Toad&Co's Annual Grilled Cheese SMACKDOWN. It was a lot of fun, and we won 4th place!
Here is the line-up of winners.
We used three types of cheese (it's not a day to count calories!): Quebec cheddar, sharp provolone and fontina. We spread tomato jam onto one of the slices of bread, piled on the cheese, and added a slice of Prosciutto cotto, an Italian style ham. The bread we used was from D'Angelo's Bakery in Santa Barbara. We chose loaves of sourdough with Kalamata olives and put lots of butter on the outside of the bread before placing the sandwich in the panini press. Once the cheese was melted, we took the sandwich out of the press and let it sit for a few seconds before opening it up and adding avocado and arugula. Voila!
"What do you think? Is it done yet?" I asked my friend Ellen who came on as sous chef.
We were the first ones to share our creation with the judges. Then we went on to make several more sandwiches that we handed out to the crowd.
The Organic Soup Kitchen was on hand serving up bowls of delicious tomato soup. I think grilled cheese and tomato soup must be one of the most iconic duos in the history of food!
Where will you be getting your grilled cheese on this coming Friday? Let us know in the comments here. Better yet, send us your favorite grilled cheese sandwich recipe to gourmetgirlsonfire@gmail.com! We'll consider it for next year's smackdown!
Congratulations on the big grilled cheese win! Personally, I believe any holiday as important as Grilled Cheese Sandwich Day should be celebrated in excess and for several days before and after April 12th. I love the Grilled Cheese recipe in the Gourmet Girls cookbook. I also love the truffle cheeses at C'est Cheese in Santa Barbara which make a supremely decadent GCS. Because GCS Day should not be limited to America, I will use some Moroccan msemen I just learned how to make and have in our freezer and put in some brie. And perhaps this recipe which I've never done before https://www.vvsupremo.com/recipe/tequila-fiesta-2-cheese-sandwich/. But never forget Velveeta or cheese whip on GCS Day! As for an accompaniment, I may substitute a Bloody Mary for the tomato soup.
Thanks Polly. Love your tips for grilled cheese yummyness! I'll definitely check out the truffle cheeses at C'est Cheese.
Thank you! And, yes, GCSD should be every day!!


text:
Call for Alzheimer's Support Group
By Chitra Nair
Stumbling in the Dark
The world marked Alzheimer's Day on Sunday, but a woeful lack of awareness and government funding impede the treatment of the disease in the city
As the world observed Alzheimer's Day on Sunday, and as we struggle to find out more about the disease, lack of awareness in the country continues to be a major hurdle to its treatment. Alzheimer's is a progressive degenerative disorder in which the nerve cells of the brain are destroyed and the brain substance decreases. It was first discovered and described by German neurologist Alois Alzheimer in 1906.
"Today, we can regard Alzheimer's as the most common form of dementia (disorder of the mental processes) that has no cure. Unlike other forms of dementia like multiinfarct dementia, Alzheimer's is a disease in which the patient's condition only worsens. On the other hand, multi–infarct dementia is a step and ladder disease in which the patient's condition gets worse one day and better the next," says psychiatrist Biswaroop Dey.
Dey runs a rehabilitation clinic for dementia patients in the city. According to him, between 1 to 2 per cent of the city's population suffers from Alzheimer's, but a majority of the cases go unreported. "There are two main reasons for this, a lack of awareness and a general refusal to accept that you or someone in your family might be suffering from the disease," says Dey. It is also important for family members to be able to recognise symptoms of Alzheimer's.
The cost of treatment also deters people from seeking medical help. "The daily cost of medicines can be as much as Rs 50 and above. What makes the situation worse is the that there is no government help for these patients and neither is there any insurance," he says.
Dey also tries to dispel various misconceptions regarding the disease, the primary one being that it affects only the elderly. "While it normally afflicts those over 60, today, even 30–year–olds are being affected by it," says Dey. There are many reasons for this. While a family history of mental illnesses is one of them, pollution, a bad lifestyle, food habits and the degeneration of the joint family, are also indirect causes. Interestingly, urban areas of the country have higher incidence of the disease.
"A recent study by a joint team from Indian and American organisations conducted by the Jaipur University on Alzheimer's in South East Asia found that while rural north India had the least incidence (only 1 percent of cases), Chennai accounted for 2.7 per cent cases," says Dey.
Prompt consultation can help doctors in helping patients. "Alzheimer's cannot be treated and once diagnosed with it, the patient has only 4 to 10 years of life. But with prompt treatment, this can be prolonged to upto 12 – 15 years," says Dey.
Dey lists increased funding for the department of mental health as an urgent need. "Besides, if the government helps medical professionals, we will be able to improve facilities and also start more rehabilitation homes. In my own case, funding for the rehabilitation clinic is still an issue. What helps is that I have a pharmaceutical company financing me," he says.
Dey reiterates that raising public awareness about the diseases is of utmost importance. There are around 150 psychiatrists handling Alzheimer's patients in the city, says Dey. "But if people are hesitant to approach them for treatment, what can be done?" he questions.
Identifying the symptoms
Loss of memory, especially of recent events or information.
Difficulty in speaking and writing or performing usual tasks.
Disorientation related to time and place.
Behavioural abnormality.
Pune does not have a self–help or support group for people suffering from Alzheimer's. Yashoda Wakankar, the secretary of SETU – the Association of Self–Help Groups, appeals to caregivers and relatives of patients of Alzheimer's to come together so that the association can help them start a self–help group. "Our association aims to help selfhelp groups solve their problems. We assist them in setting guidelines and also hold counselling courses for team leaders," she says. Caregivers and relatives can get together to share problems, help each other, and, importantly, create awareness about the disease. Wakankar can be contacted on +91 9822008035.
The Alzheimer's and Related Disorders Society of India has its Mumbai chapter at the J.J. Hospital. The society's helpline number is +91 22 23513253.
Only older people can get Alzheimer's In fact, people as young as 30 can be affected. It all depends on your lifestyle
Alzheimer's is not fatal Alzheimer's is a disease in which the brain cells slowly die.
Movies on Alzheimer's Disease
Care Giving for Patient with Alzheimer's Disease.
Treatment for Alzheimer's Disease
Risk Factors for Alzheimer's Disease
Diagnosis of Alzheimer's Disease
Causes of Alzheimer's Disease
Ten Warning Signs of Alzheimer's Disease


Leeds Community Church is a small rural Presbyterian Church located in Androscoggin County, Leeds, Maine. We are centrally located approximately 20 miles Southwest of the state capital of Augusta and 20 miles Northeast of the cities of Lewiston/Auburn. We are associated with the Presbytery of Northern New England and Mission at the Eastward (MATE).


text:
Rampage Staff
Sports Showcase
Varsity Football Folds in Second Half Against Rival on Senior Night
Photo by Angelina Logsdon
Sophomore Connor Pace (6) celebrating after the Rams make a tackle against the Richard Montgomery Rockets.
Jack Horan, Staff Writer
November 2, 2018|36 Views
Varsity football (3-6) put forth a strong effort but came up short on their senior night against the Richard Montgomery Rockets (6-3), losing 35-14.
Starting off strong, junior quarterback Dylan Monday connected with senior wide receiver Andrew Pace for a three-yard touchdown pass. Pace stood out in the first half catching a handful of passes including a reception in which Pace caught the ball towards the Rockville sidelines, and prompted the crowd go wild.
Rams defense was commanding in the first half holding the Rockets to seven points and maintaining steady pressure on the quarterback leading to numerous sacks and tackles for a loss of yards.
"We played really well in the first half, but struggled in the second half," junior quarterback Dylan Monday said. "However, I'm really happy on the way we played, and I'm looking forward to what we can do in our next game."
Many seniors stepped into the spotlight for their senior night including Pace, Antonio Villatoro and Jaylen Lawrence. They all contributed a lot on the offensive and defensive side with all three players helping the Rams gain yards in the air and on the ground, while getting a lot of tackles during the game.
"While it's disappointing to lose on my senior night, I'm still proud of my family [teammates] for never giving up during the game," Pace said.
Despite their strong first half, the Rams could not keep pace with the Rockets in the second half with the Rockets outscoring the Rams 28-8.The Rams attempted to make a comeback late into the game, cutting the lead to one touchdown. But their comeback was halted by turnovers and the Rockets added to their lead to close the game 35-14.
The Rams play their final regular season game Friday, Nov. 2 6:30 p.m. against the Albert Einstein Titans at Paint Branch High School.
Jack Horan, Game Story Editor
Jack Horan is currently a senior at RHS and the Game Story editor for the Rampage. This is his second year as a part of the Rampage after taking Intro...
MCPS Faces Decreased Enrollment
School districts throughout Maryland have reported a drop in regular enrollment numbers since the start of the 2020-21 school year. As of October, MCPS enrollment has gone...
SMOB Proposes In-School Driver's Education Class
Sensitive Student Info Compromised by Testing Company
Rampage Tweets
Tweets by RampageOnline
The Student News Site of Rockville High School
RamLinks


Waiting Time – We provide a courtesy waiting time of 20 minutes for trips that are not being billed at an hourly rate. Once a scheduled pick-up exceeds the 20 minutes waiting time grace period, we will begin adding $1(sedan)$1.3(SUV/stretch limo) for every additional one minute (starting with the scheduled pick-up time) until all the passengers are loaded and the vehicle is on its way to the destination.
Do you offer corporate accounts? Yes, we work with many companies in the area to meet their transportation needs. Contact us today to discuss how we can help your company with limo and exective transportation services.
* Book on line 24 hours a day.
* Book by fax 24 hour a day.


Tap into unknown potential through music.
If you have a love of music and a passion for helping others, music therapy is an excellent career choice. In the Music Therapy program at SRU, you'll learn to provide therapeutic musical experiences with individuals with diverse needs, helping them to reach optimal health and achieve personal growth. Through SRU's accredited Music Therapy program, you'll receive dedicated, individualized instruction and mentorship from highly skilled faculty members, not from graduate assistants.
In the Music Therapy program at SRU, you'll develop the required musicianship and clinical skills to provide therapeutic support to people of all ages with a wide range of physical, intellectual, emotional, behavioral, developmental, sensory, and social needs. Through your coursework, you will develop the competencies required of today's music therapists to work in special education, nursing homes, psychiatric treatment centers, correctional facilities, rehabilitation centers, day programs, and in private practice.
The knowledge you'll acquire in your classes will be applied through a six-stage clinical experience program. You will participate in at least 200 hours of real-world music therapy experiences with young children, adolescents, adults, and older adults. You'll gain valuable skills through our on-site music therapy clinic, which is equipped with state-of-the-art technology and a wide array of musical instruments. Your classes will involve experiential learning at every level, and this program is also unique in its focus on issues of diversity and social justice.
SRU's Music Therapy program will give you the knowledge, skills, and abilities to work as a professional in healthcare, education, and community settings. Upon completion of the program, you'll be eligible to take the national Board Certification Exam for Music Therapists by CBMT.
Minor in Psychology: Students interested in behavioral health settings may choose to minor in Psychology to enhance their knowledge of human behavior. Students interested in working with children in diverse learner classrooms may choose to take additional classes in Special Education to enhance their knowledge in this area.
Music Education: Students may choose to double major in Music Therapy and Music Education if they are interested in learning how to teach music and to use music in therapeutic, healthcare, and educational settings.


text:
package qub;

public class TypesTests
{
    public int publicInt;
    protected String protectedString = "testing this";
    private boolean privateBoolean;

    public static int staticGet5()
    {
        return 5;
    }

    public static int staticAdd1(int value)
    {
        return value + 1;
    }

    public static void staticPrimitiveEmpty()
    {
    }

    public static Void staticBoxedEmpty()
    {
        return null;
    }

    public int memberGet6()
    {
        return 6;
    }

    public int memberAdd2(Integer value)
    {
        return value + 2;
    }

    public static void test(TestRunner runner)
    {
        runner.testGroup(Types.class, () ->
        {
            runner.testGroup("containsMemberVariable(Object,String)", () ->
            {
                runner.test("with null Object", (Test test) ->
                {
                    test.assertThrows(() -> Types.containsMemberVariable(null, "parent"), new PreConditionFailure("type cannot be null."));
                });

                runner.test("with null memberVariableName", (Test test) ->
                {
                    test.assertThrows(() -> Types.containsMemberVariable(test, (String)null), new PreConditionFailure("memberVariableName cannot be null."));
                });

                runner.test("with empty memberVariableName", (Test test) ->
                {
                    test.assertThrows(() -> Types.containsMemberVariable(test, ""), new PreConditionFailure("memberVariableName cannot be empty."));
                });
            });

            runner.testGroup("containsMemberVariable(Object,Function1<java.lang.reflect.Field,Boolean>)", () ->
            {
                runner.test("with null Object", (Test test) ->
                {
                    test.assertThrows(() -> Types.containsMemberVariable((Object)null, (java.lang.reflect.Field memberVariable) -> true), new PreConditionFailure("value cannot be null."));
                });

                runner.test("with null condition", (Test test) ->
                {
                    test.assertThrows(() -> Types.containsMemberVariable(test, (Function1<java.lang.reflect.Field,Boolean>)null), new PreConditionFailure("condition cannot be null."));
                });

                runner.test("with non-matching condition", (Test test) ->
                {
                    test.assertFalse(Types.containsMemberVariable(test, (java.lang.reflect.Field memberVariable) -> false));
                });

                runner.test("with matching condition", (Test test) ->
                {
                    test.assertTrue(Types.containsMemberVariable(test, (java.lang.reflect.Field memberVariable) -> true));
                });
            });

            runner.testGroup("getMemberVariable(Object,String)", () ->
            {
                runner.test("with null Object", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMemberVariable((Object)null, "parent"), new PreConditionFailure("value cannot be null."));
                });

                runner.test("with null memberVariableName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMemberVariable(test, (String)null), new PreConditionFailure("memberVariableName cannot be null."));
                });

                runner.test("with empty memberVariableName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMemberVariable(test, ""), new PreConditionFailure("memberVariableName cannot be empty."));
                });

                runner.test("with non-existing memberVariableName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMemberVariable(test, "abc"), new PreConditionFailure("containsMemberVariable(value, memberVariableName) cannot be false."));
                });

                runner.test("with existing memberVariableName", (Test test) ->
                {
                    final java.lang.reflect.Field field = Types.getMemberVariable(test, "parent");
                    test.assertNotNull(field);
                    test.assertEqual(TestParent.class, field.getType());
                    test.assertEqual("parent", field.getName());
                });
            });

            runner.testGroup("getMemberVariable(Object,Function1<java.lang.reflect.Field,Boolean>)", () ->
            {
                runner.test("with null Object", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMemberVariable((Object)null, memberVariable -> true), new PreConditionFailure("value cannot be null."));
                });

                runner.test("with null condition", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMemberVariable(test, (Function1<java.lang.reflect.Field,Boolean>)null), new PreConditionFailure("condition cannot be null."));
                });

                runner.test("with non-matching condition", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMemberVariable(test, memberVariable -> false), new PreConditionFailure("containsMemberVariable(value, condition) cannot be false."));
                });

                runner.test("with matching condition", (Test test) ->
                {
                    final java.lang.reflect.Field field = Types.getMemberVariable(test, memberVariable -> memberVariable.getName().equals("parent"));
                    test.assertNotNull(field);
                    test.assertEqual(TestParent.class, field.getType());
                    test.assertEqual("parent", field.getName());
                });
            });

            runner.testGroup("getMemberVariableValue(Object,String)", () ->
            {
                runner.test("with null Object", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMemberVariableValue((Object)null, "skip"), new PreConditionFailure("value cannot be null."));
                });

                runner.test("with null memberVariableName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMemberVariableValue(test, null), new PreConditionFailure("memberVariableName cannot be null."));
                });

                runner.test("with empty memberVariableName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMemberVariableValue(test, ""), new PreConditionFailure("memberVariableName cannot be empty."));
                });

                runner.test("with non-existing memberVariableName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMemberVariableValue(test, "abc"), new PreConditionFailure("containsMemberVariable(value, memberVariableName) cannot be false."));
                });

                runner.test("with existing public int memberVariable", (Test test) ->
                {
                    final Integer publicInt = (Integer)Types.getMemberVariableValue(new TypesTests(), "publicInt");
                    test.assertNotNull(publicInt);
                    test.assertEqual(0, publicInt);
                });

                runner.test("with existing protected String memberVariable", (Test test) ->
                {
                    final String protectedString = (String)Types.getMemberVariableValue(new TypesTests(), "protectedString");
                    test.assertEqual("testing this", protectedString);
                });

                runner.test("with existing private object memberVariable", (Test test) ->
                {
                    final Node1<Integer> node = Node1.create(2);
                    test.assertEqual(2, Types.getMemberVariableValue(node, "value"));
                });
            });

            runner.testGroup("setMemberVariableValue(Object,String,Object)", () ->
            {
                runner.test("with null Object", (Test test) ->
                {
                    test.assertThrows(() -> Types.setMemberVariableValue((Object)null, "publicInt", 7), new PreConditionFailure("value cannot be null."));
                });

                runner.test("with null memberVariableName", (Test test) ->
                {
                    test.assertThrows(() -> Types.setMemberVariableValue(test, null, 6), new PreConditionFailure("memberVariableName cannot be null."));
                });

                runner.test("with empty memberVariableName", (Test test) ->
                {
                    test.assertThrows(() -> Types.setMemberVariableValue(test, "", 5), new PreConditionFailure("memberVariableName cannot be empty."));
                });

                runner.test("with non-existing memberVariableName", (Test test) ->
                {
                    test.assertThrows(() -> Types.setMemberVariableValue(test, "abc", 4), new PreConditionFailure("containsMemberVariable(value, memberVariableName) cannot be false."));
                });

                runner.test("with existing public int memberVariable", (Test test) ->
                {
                    final TypesTests typesTests = new TypesTests();
                    Types.setMemberVariableValue(typesTests, "publicInt", 11);
                    test.assertEqual(11, typesTests.publicInt);
                });

                runner.test("with existing protected String memberVariable", (Test test) ->
                {
                    final TypesTests typesTests = new TypesTests();
                    Types.setMemberVariableValue(typesTests, "protectedString", "abc");
                    test.assertEqual("abc", typesTests.protectedString);
                });

                runner.test("with existing private Boolean memberVariable", (Test test) ->
                {
                    final TypesTests typesTests = new TypesTests();
                    Types.setMemberVariableValue(typesTests, "privateBoolean", true);
                    test.assertEqual(true, typesTests.privateBoolean);
                });

                runner.test("with existing private object memberVariable", (Test test) ->
                {
                    final Node1<Integer> node = Node1.create(2);
                    Types.setMemberVariableValue(node, "value", 7);
                    test.assertEqual(7, node.getValue());
                });
            });

            runner.testGroup("getMemberVariables(Object)", () ->
            {
                runner.test("with null", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMemberVariables((Object)null), new PreConditionFailure("value cannot be null."));
                });

                runner.test("with Object", (Test test) ->
                {
                    final Iterable<String> actual = Types.getMemberVariables(new Object()).map(java.lang.reflect.Field::getName);
                    final Iterable<String> expected = new ArrayList<>();
                    test.assertEqual(expected, actual);
                });

                runner.test("with String", (Test test) ->
                {
                    final Iterable<String> actual = Types.getMemberVariables("test").map(java.lang.reflect.Field::getName);
                    final Iterable<String> expected = Iterable.create("value", "coder", "hash", "hashIsZero", "serialVersionUID", "COMPACT_STRINGS", "serialPersistentFields", "REPL", "CASE_INSENSITIVE_ORDER", "LATIN1", "UTF16");
                    test.assertEqual(expected, actual);
                });

                runner.test("with Test", (Test test) ->
                {
                    final Iterable<String> actual = Types.getMemberVariables(test).map(java.lang.reflect.Field::getName).where(value -> !value.equals("$jacocoData"));
                    final Iterable<String> expected = Iterable.create("name", "parent", "skip");
                    test.assertEqual(expected, actual);
                });
            });

            runner.testGroup("getMemberVariables(Class<?>)", () ->
            {
                runner.test("with null", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMemberVariables((Class<?>)null), new PreConditionFailure("type cannot be null."));
                });

                runner.test("with Object.getClass()", (Test test) ->
                {
                    final Iterable<String> actual = Types.getMemberVariables(new Object().getClass()).map(java.lang.reflect.Field::getName);
                    final Iterable<String> expected = Iterable.create();
                    test.assertEqual(expected, actual);
                });

                runner.test("with Object.class", (Test test) ->
                {
                    final Iterable<String> actual = Types.getMemberVariables(Object.class).map(java.lang.reflect.Field::getName);
                    final Iterable<String> expected = Iterable.create();
                    test.assertEqual(expected, actual);
                });

                runner.test("with String.getClass()", (Test test) ->
                {
                    final Iterable<String> actual = Types.getMemberVariables("test").map(java.lang.reflect.Field::getName);
                    final Iterable<String> expected = Iterable.create("value", "coder", "hash", "hashIsZero", "serialVersionUID", "COMPACT_STRINGS", "serialPersistentFields", "REPL", "CASE_INSENSITIVE_ORDER", "LATIN1", "UTF16");
                    test.assertEqual(expected, actual);
                });

                runner.test("with String.class", (Test test) ->
                {
                    final Iterable<String> actual = Types.getMemberVariables(String.class).map(java.lang.reflect.Field::getName);
                    final Iterable<String> expected = Iterable.create("value", "coder", "hash", "hashIsZero", "serialVersionUID", "COMPACT_STRINGS", "serialPersistentFields", "REPL", "CASE_INSENSITIVE_ORDER", "LATIN1", "UTF16");
                    test.assertEqual(expected, actual);
                });

                runner.test("with Test.getClass()", (Test test) ->
                {
                    final Iterable<String> actual = Types.getMemberVariables(test.getClass()).map(java.lang.reflect.Field::getName).where(value -> !value.equals("$jacocoData"));
                    final Iterable<String> expected = Iterable.create("name", "parent", "skip");
                    test.assertEqual(expected, actual);
                });

                runner.test("with Test.class", (Test test) ->
                {
                    final Iterable<String> actual = Types.getMemberVariables(Test.class).map(java.lang.reflect.Field::getName).where(value -> !value.equals("$jacocoData"));
                    final Iterable<String> expected = Iterable.create("name", "parent", "skip");
                    test.assertEqual(expected, actual);
                });
            });

            runner.testGroup("getMethods(Class<?>)", () ->
            {
                runner.test("with null type", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMethods(null),
                        new PreConditionFailure("type cannot be null."));
                });

                runner.test("with non-null type", (Test test) ->
                {
                    final Iterable<java.lang.reflect.Method> action0Methods = Types.getMethods(Action0.class);
                    test.assertNotNull(action0Methods);
                    test.assertEqual(Iterable.create("run", "add", "add"), action0Methods.map(method -> method.getName()));
                    test.assertEqual(Iterable.create(Action0.class, Action0.class, Action0.class), action0Methods.map(method -> method.getDeclaringClass()));
                });
            });

            runner.testGroup("getMethodSignature(Class<?>,String,Class<?>...)", () ->
            {
                runner.test("with null type", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMethodSignature(null, "methodName", Integer.class),
                        new PreConditionFailure("type cannot be null."));
                });

                runner.test("with null methodName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMethodSignature(TypesTests.class, null, Integer.class),
                        new PreConditionFailure("methodName cannot be null."));
                });

                runner.test("with empty methodName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMethodSignature(TypesTests.class, "", Integer.class),
                        new PreConditionFailure("methodName cannot be empty."));
                });

                runner.test("with null parameterTypes", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMethodSignature(TypesTests.class, "hello", (Class<?>[])null),
                        new PreConditionFailure("parameterTypes cannot be null."));
                });

                runner.test("with no parameterTypes", (Test test) ->
                {
                    test.assertEqual("qub.TypesTests.hello() -> ?", Types.getMethodSignature(TypesTests.class, "hello"));
                });

                runner.test("with one parameterType", (Test test) ->
                {
                    test.assertEqual("qub.TypesTests.hello(java.lang.Character) -> ?", Types.getMethodSignature(TypesTests.class, "hello", Character.class));
                });

                runner.test("with two parameterTypes", (Test test) ->
                {
                    test.assertEqual("qub.TypesTests.hello(short,char) -> ?", Types.getMethodSignature(TypesTests.class, "hello", short.class, char.class));
                });

                runner.test("with empty parameterTypes", (Test test) ->
                {
                    test.assertEqual("qub.TypesTests.hello() -> ?", Types.getMethodSignature(TypesTests.class, "hello", new Class<?>[0]));
                });

                runner.test("with single-element parameterTypes", (Test test) ->
                {
                    test.assertEqual("qub.TypesTests.hello(java.lang.String) -> ?", Types.getMethodSignature(TypesTests.class, "hello", new Class<?>[] { String.class }));
                });

                runner.test("with two-element parameterTypes", (Test test) ->
                {
                    test.assertEqual("qub.TypesTests.hello(java.lang.String,qub.Comparison) -> ?", Types.getMethodSignature(TypesTests.class, "hello", new Class<?>[] { String.class, Comparison.class }));
                });
            });

            runner.testGroup("getMethodSignature(Class<?>,String,Iterable<Class<?>>)", () ->
            {
                runner.test("with null type", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMethodSignature(null, "methodName", Iterable.create(Integer.class)),
                        new PreConditionFailure("type cannot be null."));
                });

                runner.test("with null methodName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMethodSignature(TypesTests.class, null, Iterable.create(Integer.class)),
                        new PreConditionFailure("methodName cannot be null."));
                });

                runner.test("with empty methodName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMethodSignature(TypesTests.class, "", Iterable.create(Integer.class)),
                        new PreConditionFailure("methodName cannot be empty."));
                });

                runner.test("with null parameterTypes", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMethodSignature(TypesTests.class, "hello", (Iterable<Class<?>>)null),
                        new PreConditionFailure("parameterTypes cannot be null."));
                });

                runner.test("with empty parameterTypes", (Test test) ->
                {
                    test.assertEqual("qub.TypesTests.hello() -> ?", Types.getMethodSignature(TypesTests.class, "hello", Iterable.create()));
                });

                runner.test("with single-element parameterTypes", (Test test) ->
                {
                    test.assertEqual("qub.TypesTests.hello(java.lang.String) -> ?", Types.getMethodSignature(TypesTests.class, "hello", Iterable.create(String.class)));
                });

                runner.test("with two-element parameterTypes", (Test test) ->
                {
                    test.assertEqual("qub.TypesTests.hello(java.lang.String,qub.Comparison) -> ?", Types.getMethodSignature(TypesTests.class, "hello", Iterable.create(String.class, Comparison.class)));
                });
            });

            runner.testGroup("getMethodSignature(Class<?>,String,Iterable<Class<?>>,Class<?>)", () ->
            {
                runner.test("with null type", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMethodSignature(null, "methodName", Iterable.create(Integer.class), int.class),
                        new PreConditionFailure("type cannot be null."));
                });

                runner.test("with null methodName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMethodSignature(TypesTests.class, null, Iterable.create(Integer.class), char.class),
                        new PreConditionFailure("methodName cannot be null."));
                });

                runner.test("with empty methodName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMethodSignature(TypesTests.class, "", Iterable.create(Integer.class), boolean.class),
                        new PreConditionFailure("methodName cannot be empty."));
                });

                runner.test("with null parameterTypes", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMethodSignature(TypesTests.class, "hello", (Iterable<Class<?>>)null, short.class),
                        new PreConditionFailure("parameterTypes cannot be null."));
                });

                runner.test("with null returnType", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMethodSignature(TypesTests.class, "hello", Iterable.create(), (Class<?>)null),
                        new PreConditionFailure("returnType cannot be null."));
                });

                runner.test("with empty parameterTypes", (Test test) ->
                {
                    test.assertEqual("qub.TypesTests.hello() -> char",
                        Types.getMethodSignature(TypesTests.class, "hello", Iterable.create(), char.class));
                });

                runner.test("with single-element parameterTypes", (Test test) ->
                {
                    test.assertEqual("qub.TypesTests.hello(java.lang.String) -> java.lang.String",
                        Types.getMethodSignature(TypesTests.class, "hello", Iterable.create(String.class), String.class));
                });

                runner.test("with two-element parameterTypes", (Test test) ->
                {
                    test.assertEqual("qub.TypesTests.hello(java.lang.String,qub.Comparison) -> boolean",
                        Types.getMethodSignature(TypesTests.class, "hello", Iterable.create(String.class, Comparison.class), boolean.class));
                });
            });

            runner.testGroup("getMethodSignature(Class<?>,String,Iterable<Class<?>>,String)", () ->
            {
                runner.test("with null type", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMethodSignature(null, "methodName", Iterable.create(Integer.class), "hello"),
                        new PreConditionFailure("type cannot be null."));
                });

                runner.test("with null methodName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMethodSignature(TypesTests.class, null, Iterable.create(Integer.class), "hello"),
                        new PreConditionFailure("methodName cannot be null."));
                });

                runner.test("with empty methodName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMethodSignature(TypesTests.class, "", Iterable.create(Integer.class), "hello"),
                        new PreConditionFailure("methodName cannot be empty."));
                });

                runner.test("with null parameterTypes", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMethodSignature(TypesTests.class, "hello", (Iterable<Class<?>>)null, "hello"),
                        new PreConditionFailure("parameterTypes cannot be null."));
                });

                runner.test("with null returnTypeFullName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMethodSignature(TypesTests.class, "hello", Iterable.create(), (String)null),
                        new PreConditionFailure("returnTypeFullName cannot be null."));
                });

                runner.test("with empty returnTypeFullName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getMethodSignature(TypesTests.class, "hello", Iterable.create(), ""),
                        new PreConditionFailure("returnTypeFullName cannot be empty."));
                });

                runner.test("with empty parameterTypes", (Test test) ->
                {
                    test.assertEqual("qub.TypesTests.hello() -> test",
                        Types.getMethodSignature(TypesTests.class, "hello", Iterable.create(), "test"));
                });

                runner.test("with single-element parameterTypes", (Test test) ->
                {
                    test.assertEqual("qub.TypesTests.hello(java.lang.String) -> ...",
                        Types.getMethodSignature(TypesTests.class, "hello", Iterable.create(String.class), "..."));
                });

                runner.test("with two-element parameterTypes", (Test test) ->
                {
                    test.assertEqual("qub.TypesTests.hello(java.lang.String,qub.Comparison) -> spam",
                        Types.getMethodSignature(TypesTests.class, "hello", Iterable.create(String.class, Comparison.class), "spam"));
                });
            });

            runner.testGroup("getRawMethod(Class<?>,String,Class<?>...)", () ->
            {
                runner.test("with null type", (Test test) ->
                {
                    test.assertThrows(() -> Types.getRawMethod(null, "method1", Integer.class),
                        new PreConditionFailure("type cannot be null."));
                });

                runner.test("with null methodName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getRawMethod(TypesTests.class, null, Integer.class),
                        new PreConditionFailure("methodName cannot be null."));
                });

                runner.test("with empty methodName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getRawMethod(TypesTests.class, "", Integer.class),
                        new PreConditionFailure("methodName cannot be empty."));
                });

                runner.test("with non-existing method name", (Test test) ->
                {
                    test.assertThrows(() -> Types.getRawMethod(TypesTests.class, "hello", Integer.class).await(),
                        new NotFoundException("No method with the signature qub.TypesTests.hello(java.lang.Integer) -> ? could be found."));
                });

                runner.test("with existing method with different parameter types", (Test test) ->
                {
                    test.assertThrows(() -> Types.getRawMethod(TypesTests.class, "staticAdd1", String.class).await(),
                        new NotFoundException("No method with the signature qub.TypesTests.staticAdd1(java.lang.String) -> ? could be found."));
                });

                runner.test("with existing static method with different parameter count", (Test test) ->
                {
                    test.assertThrows(() -> Types.getRawMethod(TypesTests.class, "staticAdd1", Integer.class, Integer.class).await(),
                        new NotFoundException("No method with the signature qub.TypesTests.staticAdd1(java.lang.Integer,java.lang.Integer) -> ? could be found."));
                });

                runner.test("with existing static method with provided boxed parameter type instead of actual primitive parameter type", (Test test) ->
                {
                    test.assertThrows(() -> Types.getRawMethod(TypesTests.class, "staticAdd1", Integer.class).await(),
                        new NotFoundException("No method with the signature qub.TypesTests.staticAdd1(java.lang.Integer) -> ? could be found."));
                });

                runner.test("with matching static method", (Test test) ->
                {
                    final java.lang.reflect.Method method = Types.getRawMethod(TypesTests.class, "staticAdd1", int.class).await();
                    test.assertNotNull(method);
                    test.assertSame(TypesTests.class, method.getDeclaringClass());
                    test.assertEqual("staticAdd1", method.getName());
                    try
                    {
                        test.assertEqual(7, method.invoke(null, 6));
                    }
                    catch (Throwable e)
                    {
                        test.fail(e);
                    }
                });

                runner.test("with existing member method with provided primitive parameter type instead of actual boxed parameter type", (Test test) ->
                {
                    test.assertThrows(() -> Types.getRawMethod(TypesTests.class, "memberAdd2", int.class).await(),
                        new NotFoundException("No method with the signature qub.TypesTests.memberAdd2(int) -> ? could be found."));
                });

                runner.test("with matching member method", (Test test) ->
                {
                    final java.lang.reflect.Method method = Types.getRawMethod(TypesTests.class, "memberAdd2", Integer.class).await();
                    test.assertNotNull(method);
                    test.assertSame(TypesTests.class, method.getDeclaringClass());
                    test.assertEqual("memberAdd2", method.getName());
                    try
                    {
                        test.assertEqual(8, method.invoke(new TypesTests(), 6));
                    }
                    catch (Throwable e)
                    {
                        test.fail(e);
                    }
                });
            });

            runner.testGroup("getStaticMethod0(Class<TType>,String)", () ->
            {
                runner.test("with null type", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod0(null, "hello"),
                        new PreConditionFailure("type cannot be null."));
                });

                runner.test("with null methodName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod0(TypesTests.class, null),
                        new PreConditionFailure("methodName cannot be null."));
                });

                runner.test("with empty methodName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod0(TypesTests.class, ""),
                        new PreConditionFailure("methodName cannot be empty."));
                });

                runner.test("with non-existing method", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod0(TypesTests.class, "blah").await(),
                        new NotFoundException("No static method with the signature qub.TypesTests.blah() -> ? could be found."));
                });

                runner.test("with existing static method with different parameter types", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod0(TypesTests.class, "staticAdd1").await(),
                        new NotFoundException("No static method with the signature qub.TypesTests.staticAdd1() -> ? could be found."));
                });

                runner.test("with existing member method", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod0(TypesTests.class, "memberGet6").await(),
                        new NotFoundException("No static method with the signature qub.TypesTests.memberGet6() -> ? could be found."));
                });

                runner.test("with existing static method with return type", (Test test) ->
                {
                    final StaticMethod0<TypesTests,?> staticMethod = Types.getStaticMethod0(TypesTests.class, "staticGet5").await();
                    test.assertNotNull(staticMethod);
                    test.assertSame(TypesTests.class, staticMethod.getType());
                    test.assertEqual(5, staticMethod.run());
                });

                runner.test("with existing static method with void return type", (Test test) ->
                {
                    final StaticMethod0<TypesTests,?> staticMethod = Types.getStaticMethod0(TypesTests.class, "staticPrimitiveEmpty").await();
                    test.assertNotNull(staticMethod);
                    test.assertSame(TypesTests.class, staticMethod.getType());
                    test.assertNull(staticMethod.run());
                });
            });

            runner.testGroup("getStaticMethod0(Class<TType>,String,Class<TReturn>)", () ->
            {
                runner.test("with null type", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod0(null, "hello", int.class),
                        new PreConditionFailure("type cannot be null."));
                });

                runner.test("with null methodName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod0(TypesTests.class, null, int.class),
                        new PreConditionFailure("methodName cannot be null."));
                });

                runner.test("with empty methodName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod0(TypesTests.class, "", int.class),
                        new PreConditionFailure("methodName cannot be empty."));
                });

                runner.test("with non-existing method", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod0(TypesTests.class, "blah", int.class).await(),
                        new NotFoundException("No static method with the signature qub.TypesTests.blah() -> int could be found."));
                });

                runner.test("with existing member method with different return type", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod0(TypesTests.class, "memberGet6", char.class).await(),
                        new NotFoundException("No static method with the signature qub.TypesTests.memberGet6() -> char could be found."));
                });

                runner.test("with existing member method with same return type", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod0(TypesTests.class, "memberGet6", int.class).await(),
                        new NotFoundException("No static method with the signature qub.TypesTests.memberGet6() -> int could be found."));
                });

                runner.test("with existing static method with different parameter types", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod0(TypesTests.class, "staticAdd1", int.class).await(),
                        new NotFoundException("No static method with the signature qub.TypesTests.staticAdd1() -> int could be found."));
                });

                runner.test("with existing static method with wrong return type", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod0(TypesTests.class, "staticGet5", char.class).await(),
                        new NotFoundException("No static method with the signature qub.TypesTests.staticGet5() -> char could be found."));
                });

                runner.test("with existing static method with return type", (Test test) ->
                {
                    final StaticMethod0<TypesTests,Integer> staticMethod = Types.getStaticMethod0(TypesTests.class, "staticGet5", int.class).await();
                    test.assertNotNull(staticMethod);
                    test.assertSame(TypesTests.class, staticMethod.getType());
                    test.assertEqual(5, staticMethod.run());
                });

                runner.test("with existing static method with wrong boxed void return type", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod0(TypesTests.class, "staticPrimitiveEmpty", Void.class).await(),
                        new NotFoundException("No static method with the signature qub.TypesTests.staticPrimitiveEmpty() -> java.lang.Void could be found."));
                });

                runner.test("with existing static method with correct primitive void return type", (Test test) ->
                {
                    final StaticMethod0<TypesTests,Void> staticMethod = Types.getStaticMethod0(TypesTests.class, "staticPrimitiveEmpty", void.class).await();
                    test.assertNotNull(staticMethod);
                    test.assertSame(TypesTests.class, staticMethod.getType());
                    test.assertNull(staticMethod.run());
                });

                runner.test("with existing static method with wrong primitive void return type", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod0(TypesTests.class, "staticBoxedEmpty", void.class).await(),
                        new NotFoundException("No static method with the signature qub.TypesTests.staticBoxedEmpty() -> void could be found."));
                });

                runner.test("with existing static method with correct boxed void return type", (Test test) ->
                {
                    final StaticMethod0<TypesTests,Void> staticMethod = Types.getStaticMethod0(TypesTests.class, "staticBoxedEmpty", Void.class).await();
                    test.assertNotNull(staticMethod);
                    test.assertSame(TypesTests.class, staticMethod.getType());
                    test.assertNull(staticMethod.run());
                });
            });

            runner.testGroup("getStaticMethod1(Class<TType>,String,Class<T1>)", () ->
            {
                runner.test("with null type", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod1(null, "hello", int.class),
                        new PreConditionFailure("type cannot be null."));
                });

                runner.test("with null methodName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod1(TypesTests.class, null, int.class),
                        new PreConditionFailure("methodName cannot be null."));
                });

                runner.test("with empty methodName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod1(TypesTests.class, "", int.class),
                        new PreConditionFailure("methodName cannot be empty."));
                });

                runner.test("with non-existing method", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod1(TypesTests.class, "blah", int.class).await(),
                        new NotFoundException("No static method with the signature qub.TypesTests.blah(int) -> ? could be found."));
                });

                runner.test("with existing static method with different parameter types", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod1(TypesTests.class, "staticAdd1", char.class).await(),
                        new NotFoundException("No static method with the signature qub.TypesTests.staticAdd1(char) -> ? could be found."));
                });

                runner.test("with existing static method", (Test test) ->
                {
                    final StaticMethod1<TypesTests,Integer,?> staticMethod = Types.getStaticMethod1(TypesTests.class, "staticAdd1", int.class).await();
                    test.assertNotNull(staticMethod);
                    test.assertSame(TypesTests.class, staticMethod.getType());
                    test.assertEqual(7, staticMethod.run(6));
                });
            });

            runner.testGroup("getStaticMethod1(Class<TType>,String,Class<T1>,Class<TReturn>)", () ->
            {
                runner.test("with null type", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod1(null, "hello", int.class, int.class),
                        new PreConditionFailure("type cannot be null."));
                });

                runner.test("with null methodName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod1(TypesTests.class, null, int.class, int.class),
                        new PreConditionFailure("methodName cannot be null."));
                });

                runner.test("with empty methodName", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod1(TypesTests.class, "", int.class, int.class),
                        new PreConditionFailure("methodName cannot be empty."));
                });

                runner.test("with non-existing method", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod1(TypesTests.class, "blah", int.class, int.class).await(),
                        new NotFoundException("No static method with the signature qub.TypesTests.blah(int) -> int could be found."));
                });

                runner.test("with existing member method with different return type", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod1(TypesTests.class, "memberGet6", int.class, char.class).await(),
                        new NotFoundException("No static method with the signature qub.TypesTests.memberGet6(int) -> char could be found."));
                });

                runner.test("with existing member method with same return type", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod1(TypesTests.class, "memberGet6", int.class, int.class).await(),
                        new NotFoundException("No static method with the signature qub.TypesTests.memberGet6(int) -> int could be found."));
                });

                runner.test("with existing static method with different parameter types", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod1(TypesTests.class, "staticAdd1", char.class, int.class).await(),
                        new NotFoundException("No static method with the signature qub.TypesTests.staticAdd1(char) -> int could be found."));
                });

                runner.test("with existing static method with wrong return type", (Test test) ->
                {
                    test.assertThrows(() -> Types.getStaticMethod1(TypesTests.class, "staticAdd1", int.class, char.class).await(),
                        new NotFoundException("No static method with the signature qub.TypesTests.staticAdd1(int) -> char could be found."));
                });

                runner.test("with existing static method with return type", (Test test) ->
                {
                    final StaticMethod1<TypesTests,Integer,Integer> staticMethod = Types.getStaticMethod1(TypesTests.class, "staticAdd1", int.class, int.class).await();
                    test.assertNotNull(staticMethod);
                    test.assertSame(TypesTests.class, staticMethod.getType());
                    test.assertEqual(7, staticMethod.run(6));
                });
            });

            runner.testGroup("instanceOf(Object,Class<?>)", () ->
            {
                final Action3<Object,Class<?>,Boolean> instanceOfTest = (Object value, Class<?> type, Boolean expected) ->
                {
                    runner.test("with " + English.andList(Strings.escapeAndQuote(value), type), (Test test) ->
                    {
                        test.assertEqual(expected, Types.instanceOf(value, type));
                    });
                };

                instanceOfTest.run(null, null, true);
                instanceOfTest.run(null, String.class, false);
                instanceOfTest.run("hello", null, false);
                instanceOfTest.run("hello", Number.class, false);
                instanceOfTest.run("hello", String.class, true);
                instanceOfTest.run("hello", CharSequence.class, true);
                instanceOfTest.run("hello", Object.class, true);
            });

            runner.testGroup("instanceOf(Class<?>,Class<?>)", () ->
            {
                final Action3<Class<?>,Class<?>,Boolean> instanceOfTest = (Class<?> subType, Class<?> type, Boolean expected) ->
                {
                    runner.test("with " + English.andList(subType, type), (Test test) ->
                    {
                        test.assertEqual(expected, Types.instanceOf(subType, type));
                    });
                };

                instanceOfTest.run(null, null, true);
                instanceOfTest.run(null, String.class, false);
                instanceOfTest.run(String.class, null, false);
                instanceOfTest.run(String.class, Number.class, false);
                instanceOfTest.run(String.class, String.class, true);
                instanceOfTest.run(String.class, CharSequence.class, true);
                instanceOfTest.run(String.class, Object.class, true);
            });

            runner.testGroup("instanceOf(Object,Iterable<Class<?>>)", () ->
            {
                final Action3<Object,Iterable<Class<?>>,Throwable> instanceOfErrorTest = (Object value, Iterable<Class<?>> types, Throwable expected) ->
                {
                    runner.test("with " + English.andList(Strings.escapeAndQuote(value), types), (Test test) ->
                    {
                        test.assertThrows(() -> Types.instanceOf(value, types), expected);
                    });
                };

                instanceOfErrorTest.run(null, null, new PreConditionFailure("types cannot be null."));
                instanceOfErrorTest.run(null, Iterable.create(), new PreConditionFailure("types cannot be empty."));

                final Action3<Object,Iterable<Class<?>>,Boolean> instanceOfTest = (Object value, Iterable<Class<?>> types, Boolean expected) ->
                {
                    runner.test("with " + English.andList(Strings.escapeAndQuote(value), types), (Test test) ->
                    {
                        test.assertEqual(expected, Types.instanceOf(value, types));
                    });
                };

                instanceOfTest.run(null, Iterable.create((Class<?>)null), true);
                instanceOfTest.run(null, Iterable.create(String.class), false);
                instanceOfTest.run("hello", Iterable.create((Class<?>)null), false);
                instanceOfTest.run("hello", Iterable.create(Number.class), false);
                instanceOfTest.run("hello", Iterable.create(String.class), true);
                instanceOfTest.run("hello", Iterable.create(CharSequence.class), true);
                instanceOfTest.run("hello", Iterable.create(CharSequence.class, String.class), true);
                instanceOfTest.run("hello", Iterable.create(CharSequence.class, Object.class), true);
                instanceOfTest.run("hello", Iterable.create(CharSequence.class, Number.class), true);
                instanceOfTest.run("hello", Iterable.create(Object.class), true);
            });

            runner.testGroup("instanceOf(Class<?>,Iterable<Class<?>>)", () ->
            {
                final Action3<Class<?>,Iterable<Class<?>>,Throwable> instanceOfErrorTest = (Class<?> subType, Iterable<Class<?>> types, Throwable expected) ->
                {
                    runner.test("with " + English.andList(Strings.escapeAndQuote(subType), types), (Test test) ->
                    {
                        test.assertThrows(() -> Types.instanceOf(subType, types), expected);
                    });
                };

                instanceOfErrorTest.run(null, null, new PreConditionFailure("types cannot be null."));
                instanceOfErrorTest.run(null, Iterable.create(), new PreConditionFailure("types cannot be empty."));

                final Action3<Class<?>,Iterable<Class<?>>,Boolean> instanceOfTest = (Class<?> subType, Iterable<Class<?>> types, Boolean expected) ->
                {
                    runner.test("with " + English.andList(Strings.escapeAndQuote(subType), types), (Test test) ->
                    {
                        test.assertEqual(expected, Types.instanceOf(subType, types));
                    });
                };

                instanceOfTest.run(null, Iterable.create((Class<?>)null), true);
                instanceOfTest.run(null, Iterable.create(String.class), false);
                instanceOfTest.run(String.class, Iterable.create((Class<?>)null), false);
                instanceOfTest.run(String.class, Iterable.create(Number.class), false);
                instanceOfTest.run(String.class, Iterable.create(String.class), true);
                instanceOfTest.run(String.class, Iterable.create(CharSequence.class), true);
                instanceOfTest.run(String.class, Iterable.create(CharSequence.class, String.class), true);
                instanceOfTest.run(String.class, Iterable.create(CharSequence.class, Object.class), true);
                instanceOfTest.run(String.class, Iterable.create(CharSequence.class, Number.class), true);
                instanceOfTest.run(String.class, Iterable.create(Object.class), true);
            });

            runner.testGroup("as(Object)", () ->
            {
                runner.test("null as Integer", (Test test) ->
                {
                    test.assertNull(Types.as(null, Integer.class));
                });

                runner.test("Integer as null", (Test test) ->
                {
                    test.assertThrows(() -> Types.as(20, null),
                        new PreConditionFailure("type cannot be null."));
                });

                runner.test("Integer as Number", (Test test) ->
                {
                    final Number number = Types.as(50, Number.class);
                    test.assertNotNull(number);
                    test.assertEqual(50, number.intValue());
                });

                runner.test("Integer as Integer", (Test test) ->
                {
                    final Integer integer = Types.as(50, Integer.class);
                    test.assertNotNull(integer);
                    test.assertEqual(50, integer);
                });

                runner.test("Integer as Float", (Test test) ->
                {
                    test.assertNull(Types.as(50, Float.class));
                });

                runner.test("Integer as String", (Test test) ->
                {
                    test.assertNull(Types.as(50, String.class));
                });
            });

            runner.testGroup("getTypeName(Object)", () ->
            {
                runner.test("with null", (Test test) ->
                {
                    test.assertEqual("null", Types.getTypeName((Object)null));
                });

                runner.test("with Object", (Test test) ->
                {
                    test.assertEqual("Object", Types.getTypeName(new Object()));
                });

                runner.test("with String", (Test test) ->
                {
                    test.assertEqual("String", Types.getTypeName("abc"));
                });
            });

            runner.testGroup("getTypeName(Class<?>)", () ->
            {
                runner.test("with null", (Test test) ->
                {
                    test.assertEqual("null", Types.getTypeName((Class<?>)null));
                });

                runner.test("with Object.getClass()", (Test test) ->
                {
                    test.assertEqual("Object", Types.getTypeName(new Object().getClass()));
                });

                runner.test("with Object.class", (Test test) ->
                {
                    test.assertEqual("Object", Types.getTypeName(Object.class));
                });

                runner.test("with String", (Test test) ->
                {
                    test.assertEqual("String", Types.getTypeName("abc".getClass()));
                });

                runner.test("with String.class", (Test test) ->
                {
                    test.assertEqual("String", Types.getTypeName(String.class));
                });
            });

            runner.testGroup("getTypeNameFromFullTypeName(String)", () ->
            {
                final Action2<String,Throwable> getTypeNameFromFullTypeNameErrorTest = (String fullTypeName, Throwable expected) ->
                {
                    runner.test("with " + Strings.escapeAndQuote(fullTypeName), (Test test) ->
                    {
                        test.assertThrows(() -> Types.getTypeNameFromFullTypeName(fullTypeName),
                            expected);
                    });
                };

                getTypeNameFromFullTypeNameErrorTest.run(null, new PreConditionFailure("fullTypeName cannot be null."));
                getTypeNameFromFullTypeNameErrorTest.run("", new PreConditionFailure("fullTypeName cannot be empty."));

                final Action2<String,String> getTypeNameFromFullTypeNameTest = (String fullTypeName, String expected) ->
                {
                    runner.test("with " + Strings.escapeAndQuote(fullTypeName), (Test test) ->
                    {
                        test.assertEqual(expected, Types.getTypeNameFromFullTypeName(fullTypeName));
                    });
                };

                getTypeNameFromFullTypeNameTest.run("a", "a");
                getTypeNameFromFullTypeNameTest.run("a.b", "b");
                getTypeNameFromFullTypeNameTest.run("a.b$1", "b$1");
            });

            runner.testGroup("getFullTypeName(Object)", () ->
            {
                runner.test("with null", (Test test) ->
                {
                    test.assertEqual("null", Types.getFullTypeName((Object)null));
                });

                runner.test("with Object", (Test test) ->
                {
                    test.assertEqual("java.lang.Object", Types.getFullTypeName(new Object()));
                });

                runner.test("with String", (Test test) ->
                {
                    test.assertEqual("java.lang.String", Types.getFullTypeName("abc"));
                });
            });

            runner.testGroup("getFullTypeName(Class<?>)", () ->
            {
                runner.test("with null", (Test test) ->
                {
                    test.assertEqual("null", Types.getFullTypeName((Class<?>)null));
                });

                runner.test("with Object.getClass()", (Test test) ->
                {
                    test.assertEqual("java.lang.Object", Types.getFullTypeName(new Object().getClass()));
                });

                runner.test("with Object.class", (Test test) ->
                {
                    test.assertEqual("java.lang.Object", Types.getFullTypeName(Object.class));
                });

                runner.test("with String", (Test test) ->
                {
                    test.assertEqual("java.lang.String", Types.getFullTypeName("abc".getClass()));
                });
            });
        });
    }
}

redpajama_set_name: RedPajamaGithub


At Rejuvenation Clinics of Australia we hold our clients in the highest regard and we want to reward you for your loyal custom, that's why it pays to keep coming back to Sydney's leading cosmedic clinics.
For each dollar you spend at our clinics you earn a reward point: $1,000 = 1,000 points!
Points can be used against any of the treatments & products at Rejuvenation Clinics of Australia* so why not book in your next appointment before you leave and start saving?
A referral is the greatest compliment you can pay us, so we want to return the favour!
You can also accumulate reward points by sending your friends, family and work colleagues to Rejuvenation Clinics of Australia for treatments – just make sure they are new to Rejuvenation Clinics of Australia and mention your name at the point of booking.
From time to time we also offer bonus points on certain products and treatments, details will be in store or online, but the best way to save is to sign up to our newsletter for advanced notice of all our special offers and promotions.
You don't! Your points balance will automatically be added to your account whenever you make a purchase at Rejuvenation Clinics of Australia.
Your running points balance will be displayed on your receipt after each purchase. Alternatively you can ask one of our friendly staff to retrieve your current points balance.
When can I claim my points?
Your points will be available for use the day after your purchase.
Points expire 12 months from the date of your last purchase at Rejuvenation Clinics of Australia, if you make a new purchase you will have another 12 months before your points expire.
We always endeavour to notify customers 1 month prior to the expiry of their points balance.
* Rejuvenation Clinics of Australia reserves the right to refuse reward points redemption where explicitly stated such as, but not limited to: exceptional offers; promotions in conjunction with 3rd parties and any services operated by Specialist Clinics of Australia. Reward points are non-refundable, non-transferable and not redeemable for cash.