text:
Posts Tagged 'Hydration'
Assisted Suicide, Hydration, Mercy Killing
The Silent Killer: An Argument Against Euthanasia
In 09 Mary Summa, JD on 2012/09/13 at 9:11 AM
By Mary Summa, J.D."He's not responding. What do you want us to do with him? What are your plans?"The young woman had been sitting beside her father, holding his hand. The elderly man was a pillar of the community, a devoted husband, a loving father, a hero to those who knew him. She looked up to see the hospital social worker—file in hand—ready to write down her instructions. Her father had suffered a massive stroke five days before, which the doctors expected to kill him. By the grace of God, he had rallied."We're having a gastro feeding tube put in next week," the daughter responded. The social worker looked at her as if she was a stupid child. "Oh, everyone likes to feed their family members, but it's not so bad after a couple of days."The daughter could not believe her ears! She looked the social worker straight in the eye. "We are feeding my father. We are not starving him to death."The social worker snapped her file shut, turned and exited the room. She did not like what she heard. The daughter didn't either.This true encounter illustrates the diminished value placed on human life in America today. Previously, our long-held belief that life is sacred had deemed all forms of intentional killing including abortion, infanticide, euthanasia, and suicide to be ethically wrong. Doctors' and nurses' commitment to this basic principle would have led them to do everything they could to keep this man alive. To have even suggested to a daughter that she consent to starving her father would have been unheard of, much less promoted.Now, in 2009, as this woman discovered, our nation's rejection of God has real ramifications. Without God, man has no inalienable rights, including the right to live; only life with a utilitarian value deserves protection. Otherwise, extinguishing that life by starvation is morally acceptable.In order to understand how our nation has slid into this abyss and what we can do about it, one must understand what euthanasia is, where it came from and what is legally happening in North Carolina and elsewhere.
The word "euthanasia" derives from the Greek word for "easy death."1 Euthanasia is defined as the "intentional killing by act or omission of a dependent human being for his or her alleged benefit." There are two types of euthanasia. (1) Euthanasia by omission ends a patient's life by withdrawing medicines or food and water necessary to sustain life. (2) Euthanasia by action is achieved by administering a treatment or lethal dose of medication to a patient who has requested to die. Either form of euthanasia can be voluntary where the patient consents to the euthanasia; non-voluntary where the patient did not make a request or give consent; or involuntary where the patient withheld consent.2
Origin and History of Euthanasia
Euthanasia dates back to Ancient Greece and Rome when doctors commonly administered poisons to hasten the death of patients.3 The growth of the Christian Church caused support for euthanasia to wane and Western governments, for the most part, condemned euthanasia until the 20th Century.4
While a few doctors and philosophers promoted euthanasia in the 18th and 19th Centuries, it failed to gain much support until the early 1930's. Then, on October 16, 1931, C. Killick Millard, the Medical Officer of Health for the City of Leicester in Britain, reignited the debate by calling voluntary euthanasia "rational, courageous and often highly altruistic" and proposed a draft bill. Undaunted by his lack of success in Parliament, in 1935 Millard founded the Voluntary Euthanasia Legalization Society (VELS) to promote his cause.5 Some historians have suggested that the VELS, although framed as an organization promoting "voluntary" euthanasia, in fact, obscured the distinctions between voluntary and involuntary euthanasia and sympathized with Nazi euthanasia.6
For the next 40 years, the Euthanasia Movement continued to organize voluntary euthanasia societies around the world. In 1973, voluntary euthanasia societies formed in the Netherlands; in 1976 in Japan and Germany. That same year the first international conference of voluntary euthanasia associations was held in Tokyo.7
The U.S. Euthanasia Movement
In the United States, just as in Europe, the voluntary Euthanasia Movement preceded judicial and legislative victories permitting euthanasia. In 1935, the same year Millard established the VELS in Britain, Reverend Charles Potter founded a lobbying group in the U.S. called the Euthanasia Society in America. The U.S. organization's goals extended well beyond those of its British counterpart. Unlike the British organization, which fostered "voluntary" euthanasia, the Euthanasia Society in America aspired to legalize all euthanasia, voluntary and involuntary. In 1942, Foster Kennedy, M.D., a former president of the Society, while criticizing euthanasia laws that "ignore creatures who cannot speak," offered a plan of involuntary euthanasia for defective children. Eight years later, in 1950, Reverend Potter publicly praised and supported the "mercy killing" of two cancer patients. The Society had moved very quickly from the position of supporting the killing of those who "want" to die to those who "should" ask to die.8
The philosophical table was set for judicial and legislative action to legalize the taking of human life, whether the patient expressed the desire to die or not.
Physician-Assisted Suicide
The Euthanasia Movement has had limited success in legalizing physician-assisted suicide, a type of voluntary, active euthanasia, which can be accomplished through direct consent from the patient or indirectly through a living will. Either through court action or legislative mandate, only three countries—Netherlands, Belgium, and Luxembourg—have legalized physician-assisted suicide.9 Switzerland does not officially allow physician-assisted suicide, but the government will not prosecute physicians who engage in it.10 In Uruguay and Columbia, "mercy killings" are not prosecuted.11 Just this year in Britain, the Director of Prosecutions issued a similar directive to prosecutors to withhold prosecutions against individuals who assist in suicide.12
In the U.S., there have been many attempts but few successes to legalize physician-assisted suicide. The Ohio State Legislature made the first attempt in 1906. That bill failed 79-23.13 The International Task Force on Euthanasia and Assisted Suicide reports that between 1994 and 2009, 24 state legislatures entertained a total of 113 bills that would have legalized this type of active euthanasia. All attempts failed. Between 1991 and 2000, four states entertained ballot initiatives to legalize physician-assisted suicide. All failed. In 1997, Oregon legalized physician-assisted suicide, followed by Washington State in 2008, which legalized it by referendum.14 Currently, the Montana Supreme Court is considering the constitutionality of physician-assisted suicide.15
Euthanasia "by Omission"
While the Euthanasia Movement has made slow progress in courthouses and state legislatures with physician-assisted suicide, it has knocked the hinges off the backdoors of hospital rooms and nursing homes with euthanasia "by omission." Judicial implementation of a legal fiction called "substituted judgment" and legislatures' broadening of the definition of "medical treatment" has led to the passive euthanasia of countless individuals in this country and abroad, primarily through the withdrawal of food and water to living patients (i.e., silent euthanasia). Here's how it happened:
As technological advances allowed the elderly to live longer, bio-ethicists began to question, "How much is too much?" In 1983, Daniel Callahan, a bio-ethicist and co-founder of the Hastings Center, wrote "On Feeding the Dying." In that article he stated the widely held view that "…a denial of nutrition, may, in the long run, become the only effective way to make certain that a large number of biologically tenacious patients actually die…Given the increasingly large pool of superannuated, chronically ill, physically marginal elders, it could well become the non-treatment of choice." He recognized, however, that society's "deep-seated revulsion" to starving patients to death would prolong the journey toward legalization of the practice.16 While not totally convinced in 1983, Daniel Callahan 10 years later wholeheartedly endorsed the starvation of patients in a "vegetative" state.17 Most recently, he has joined the torch-bearers for rationed, government-run health care.18
While bio-ethicists deliberated the ethics of using advancing technology on the elderly, the Euthanasia Movement's leaders saw an opportunity to advance the cause. In 1984, Helga Kuhse, a leader in the Euthanasia Movement and a philosophy professor at Australia's Monash University, seized the opportunity. At an international conference, she informed the audience that by showing the public how painful death by dehydration and starvation really is, society would conclude that a lethal injection is "in the patient's best interest." In effect, coming in the backdoor will accomplish what the Euthanasia Movement was unable to accomplish through the front.19
Social and verbal re-engineering was needed to accomplish this long-term goal. First, euthanasia proponents needed to transform the simple procedure of inserting a feeding tube into a complicated "medical treatment" in order to disguise the desire to starve a patient.20
The often-cited story of Mary Hier illustrates how verbal re-engineering can affect the outcome. Mrs. Hier was a 92-year-old patient suffering from severe dementia, but not terminally ill. An abnormality in her esophagus required that she be tube-fed for many years. When her tube became dislodged, the court denied the petition of her guardian ad litem to reinsert it, citing the "relatively high risk" to the patient of performing this "major medical procedure."21 On the same day the paper reported on the Hier case, it also reported on a 94-year-old woman who received the same procedure, now characterized as "minor surgery to correct a nutritional problem." The woman was Rose Kennedy. Eventually, Mrs. Heir's feeding tube was reinserted and she and Mrs. Kennedy lived for several more years.22
This dichotomy in the characterization of the same procedure begs the question, "Is it called a 'medical procedure' when the real intent is to starve the patient?" In truth, gastrostomy tubes (G-tubes) have been around for at least 100 years.23 In the early 1980s the technique was perfected so as to be performed in a 30 minute procedure.24
While the "food and hydration" debate has focused on "artificial" feeding through tubes, some courts and ethicists have argued that there is no distinction between food given "artificially" and that given by mouth. Both should be considered "medical treatment," which can be withdrawn from a patient.25
Still others have argued that removing a ventilator is morally equivalent to removing artificial food and hydration. There is, however, a very clear distinction. Without a ventilator, the patient will die due to the underlying condition, which perpetrated the decision to ventilate the patient. Without food and hydration, the person will die of a new cause—deliberate starvation and dehydration—not the underlying condition, which prompted insertion of the feeding tube.26
Lastly, medical and law journals are filled with the burden/benefit argument—a low quality of life is considered in light of the "burden" to the hospital, the family and society. In this argument, the patient is not dying (or not dying fast enough), and it is deemed best to end the patient's suffering. The response is philosophical—The sanctity of human life gives it intrinsic value. A person's value and right to live should not be determined by his/her utilitarian value.
Judicial and Legislative Action
The Euthanasia Movement has won tremendous victories over the past 25 years. First, the case of Karen Ann Quinlan provided the foothold needed for the Euthanasia Movement in America by allowing parents to remove their daughter's ventilator. In 1990, the Supreme Court declared in the Cruzan case that the "right to die" is protected under the Due Process Clause of the Constitution. While the court did not rule specifically on whether food and water could be treated as "treatment," which could be withdrawn from the patient, nonetheless, that was the effect. The Cruzan family was allowed to kill their child by withdrawing her food and water.27
The Schiavo case ranks as the most public of all euthanasia cases. It highlighted for the world that food and hydration are no longer considered medical "care," but are "medical treatment," and can be withdrawn from any patient. Using a "legal fiction" of substituted judgment, the courts decided that Terri Schiavo would have wanted her feeding tube to be withdrawn.28 Terri died 13 days after her feeding tube was removed by court order.29 In effect, the courts ruled just as the Euthanasia Society of America wanted in 1950: What a patient wants has been supplanted with what a patient "should" want.30
Most courts and state legislatures have fallen into the arms of the Euthanasia Movement and now characterize artificial food and hydration as "medical treatment," which can be withheld at the consent of the patient or another person acting on the patient's behalf. Many states allow food and hydration to be withdrawn by legislative mandate or court action.
North Carolina succumbed to the Euthanasia Movement relatively early. In 1991, the North Carolina legislature authorized "Living Wills" and "Health Care Powers of Attorney."31 In that statute, "Life-Prolonging Measures," which can be withdrawn by a physician with consent of the patient or an agent of the patient, include "artificial nutrition and hydration." So, in North Carolina, it is legal for a doctor to starve a patient to death as long as he receives some kind of consent from the patient or the patient's designee.
Although many have supported voluntary euthanasia—euthanasia with the consent of the patient or the patient's designee—others have argued that the distinction between voluntary and involuntary euthanasia is fleeting. That conclusion has proven prophetic.
Chris Docker, Director of the Scottish euthanasia group, Exit, wrote a paper in 1996 suggesting that when a patient is in a persistent vegetative state (PVS), the consent of the patient's loved one should be replaced with "institutional guidelines developed by the professional associations." These guidelines "could be developed for other conditions as well as PVS where the patient's preference is no longer the most relevant factor."32
Sadly, Mr. Docker did not have to wait long to see his theory put into action. In the fall of 2009, The Daily Telegraph (a London-based newspaper) reported several cases where hospitals euthanized or attempted to euthanize non-terminally ill patients under the British Palliative Care Program, the "Liverpool Care Pathway."33
Shockingly, according to a recently released audit of the program, 28 percent of the families did not even know that their loved ones were put into the Liverpool Care Pathway.34
Natural rights, including the right to life, serve as the foundation of our democracy. Preserving these rights insures freedom. Destroying them guarantees tyranny.
"If we wish to be free," Patrick Henry once said, "We must fight."35 Turning our nation from a culture of death to a culture of life will not be easy. The Euthanasia Movement is a formidable foe, but for the sake of human freedom and dignity, we must be willing to fight the battle.
To begin this quest to regain our freedom, state legislatures should criminalize physician-assisted suicide. Despite legalization in only two states, many states, including North Carolina, remain silent on the issue, leaving the door wide open for physicians to engage in this ghastly act with impunity. Secondly, state laws should designate food and hydration, including "artificial" food and hydration, as "care" not "treatment" which can be withdrawn. We need to be a nation which honors the living, not one which abandons the dying.
No one should be put through the scene described at the outset of this article. I understand the pain. You see, I was the daughter and my father was the patient. My father regained his ability to speak, understand, eat and sit up on his own. He lived for three more months, giving my siblings and me, and, most importantly, our mother, the opportunity to take care of him the way he took care of us all our lives. In his dying hours, Dad held my hand, with extra squeezes in the same rhythm that he used when I was a little girl. He died in God's time, not the hospital's, in the wee hours of a warm summer morning while I, alone in his hospital room, held his hand reciting the 23rd Psalm.
1 Dowbiggin, Ian, "A Prey on the Normal People': C. Killick Millard and the Euthanasia Movement in great Britain, 1930-55", Journal of Contemporary History, Vol. 36, No. 1. 59-85. 2001. Sage Journals Online. 8 Nov. 2009.
2 "Euthanasia Definitions", Euthanasia.com. 4 Dec. 2009. <www.euthanasia.com/definitions.html>
3 Emanuel, Ezekiel J., "The History of Euthanasia Debates in the United States and Britain," Annals of Internal Medicine, Vol 121 pp. 793-802 (1994) 793. 4 Nov. 2009. <http:annals.highwire.org/content/121/10/793.abstract>
4 Euthanasia's resurgence in the 1800's coincided with a philosophical shift in man's view of the origin of law. From the 1200's when Thomas Aquinas published Summa Theologica until the 1700's, most political philosophers accepted the Thomastic theory that laws of a society should be based on natural law. Jeremy Bentham, an 18th Century British philosopher, challenged the philosophical cornerstone that God's natural law could be discerned by reason and known to everyone. He argued that law based on natural law and the rights attached to that law were "nonsense on stilts."4 Rather, Bentham argued, the morality of a law should reflect its overall benefit to society. Hence, human life has no value unless it provides an overall societal benefit. Viewed as a political radical, mainstream political scientists ignored Bentham's theory.
Nonetheless, this theory did not die entirely. A follower of Bentham's theory, John Stuart Mill, retooled the theory, and in 1861 published a thesis titled "Utilitarianism," which rejected natural law. Mill's position as a highly respected member of Parliament and political theorist gave utilitarianism credence it had previously not enjoyed.
In America, the Founding Fathers were very influenced by philosophers who argued in favor of natural law and natural rights. "We hold these truths to be self-evident," Jefferson wrote in the Declaration of Independence, "that all men are created equal; that they are endowed by their creator with certain inalienable rights; that among these rights are life, liberty and the pursuit of happiness." The Founding Fathers believed in natural law and believed the preservation of these rights were worth sacrificing everything, including their own lives.
5 C. Ann Potter, C. Ann. "Will the 'Right to Die ' Become a License to Kill? The Growth of Euthanasia in America", 19 Journal of Legislation 31, Notre Dame Law Review. 34. See also, Ezechiel Emanuel, 796.
6 Ian Dowbiggin, Ian. 59-85.
7 Docker, Chris. "A Short History of Important Events, Scottish Voluntary Euthanasia Society. 1995.
8 Potter, C. Ann. 34.
9 Baklinksi, Thaddeus. "Luxenbourg Legalizes Euthanasia." LifeSiteNews.com. 18 March 2009.18 Nov. 2009. 4 Dec 2009. http://www.lifesitenews.com/ldn/2009/mar/09031803.html
10 White, Hillary, "Switzerland Refuses to Alter Assisted Suicide to Nix Death Tourism." LifeSiteNews.com. June 2, 2006,. 4 Dec 2009. http://www.lifesitenews.com/ldn/2006/jun/06060210.html.
11 Aysegil Demirhan Erdemir, M.D ,"A Short History of Euthanasia Laws, and Their Place in Turkish Law", Eubios Journal of Asian and International Bioethics 11 (2001), 47-49 rpt at < http://www.eubios.info/EJ112/EJ2F.htm>
12 Gilbert, Kathleen, "Britain Won't Prosecute Assisted Suicide: Chief Prosecutor," LifeSiteNews.com. 21 Sept. 2009. 4 Dec. 2009. <http://www.lifesitenews.com/ldn/2009/sep/09092109.html>
13 Ezekiel, Emanuel. 796.
14 "Failed Attempts to Legalize Euthanasia/Assisted Suicide in the United States." International Task Force.org. 4 Dec. 2009. http://www.internationaltaxkforce.org/usa.htm
15 "Montana's Top Court to Hear Right-to-Die Argument,." CNN.com/US. 1 Sept 2009. 4 Dec 2009. < http://www.cnn.com/2009/US/09/01/montana.right.to.die/index.html>
16 Callahan, Daniel. "On Feeding the Dying," Hastings Center Report, October 1983. 22.
17 Callahan, Daniel, et. al. "The Sanctity of Life Seduced: A symposium on Medical Ethics," April 1994. 4 Dec. 2009. Reprinted at <http://www.firstthings.com/article/2009/001-the-sanctity-of-life-seduced-a-symposium-on-medical-ethics-8>
18 Callahan, Daniel. "America's Blind Spot: Health Care and the Common Good" Commonweal Magazine. Vol. CXXXVI, No. 17. 9 Oct 2009. 4 Dec 2009.
<http://www.commonwealmagazine.org/article.php3?id_article=2659>
19 Marker, Rita L., Smith, Wesley J. "The Art of Verbal Engineering", Dusquene Law Review. Vol. 35. No. 1. Fall 1996. 81-107. 4 Dec 2009. Reprinted at
20 Marker, Rita, Smith, Wesley. 96.
22 See In re Hier, 18 Mass. App 200, 464 N.E. 2d 959 (1984).
23 Marker, Rita L., Smith, Wesley J. 97.
24 Minard, MD, Gaule, "The History of Surgically Placed Feeding Tubes", "Nutrition in Clinical Practice", Vol. 21. No. 6. 626-633 (2006). Sage Journals Online. 4 Dec 2009. Also see Marker, Rita L., Smith, Wesley J., fn 70.
25 See "Gastrostomy", Surgeryencyclopedia.com. 6 Nov 2009. <http://ncp.sagepub.com/cgi/content/abstract/21/6/626>
26 Marker, Rita L., Smith, Wesley J.. 99. See fn 80.
27 Grimstad, Julie, "Providing Nutrition and Hydration to Patients," Women for Faith and Family, September 2000. 4 Dec 2009.
28 Cruzan v. Director, Missouri Department of Health, 110 S. Ct. 2841 (1990).
29 Snead, Carter O., "The 'Surprising' Truth About Schiavo: A Defeat for the Cause of Autonomy." Constitutional Commentary. Winter 2005. 1-18. 4 Dec 2009.
30 "Terri's Story." Terri Schindler Schiavo Foundation. 4 Dec 2009. http://www.terrisfight.org/pages.php?page_id=3
31 Potter, C. Ann. 35.
32 Docker, Chris. "Limitations of the Best Interests and Substituted Judgment Standards: A Brief Argument to Suggest that the Law's Current Mechanisms for Making Decisions About Incompetent Persons Are Inadequate." Dying In Dignity Mensa Sig News Journal. Vol 3. Issue 1. 1-11. 1993. 23 Nov 2009. http://www.euthanasia.cc/bi.html
33 Blake, Heidi, "Fighting for a Peaceful, Pain-Free Death." Daily Telegraph. 23 Nov 2009, 8 Dec 2009. http://www.telegraph.co.uk/health/6613732/Fighting-for-a-peaceful-pain-free-death.html;
Devlin, Katie. "Sentenced to Death on the NHS." Daily Telegraph. 2 Sept 2009. 9 Dec 2009. < http://www.telegraph.co.uk/health/healthnews/6127514/Sentenced-to-death-on-the-NHS.html>; Devlin, Kate. Irvine, Chris. "Daughter Claims Father Wrongly Placed on Controversial NHS End-of-Life Scheme." Daily Telegraph. 8 Sept 2009. 9 Dec 2009. <http://www.telegraph.co.uk/health/healthnews/6156076/Daughter-claims-father-wrongly-placed-on-controversial-NHS-end-of-life-scheme.html>; See also Smith, Wesley. "Hazardous Pathway." National Review Online. 20 Oct 2009. 9 Dec 2009. <http://article.nationalreview.com/?q=MzVjMTU3ZGE2MDVkM2ZjMTg1YTY3NDIwYjdmOWZmYTE=&w=MQ=>
34 "National Care of Dying Audit—Hospitals, Round 2, Geriatric Report 2008/2009." Marie Curie Palliative Care Institute Liverpool in collaboration with Clinical Standards Department of the Royal College of Physicians. 7.
35 Henry, Patrick. "Give Me Liberty or Give Me Death." 23 March 1775. 5 Dec 2009 <http://avalon.law.yale.edu/18th_century/patrick.asp>
Mary Summa, J.D., is an attorney in Charlotte, North Carolina.
Copyright © 2010. North Carolina Family Policy Council. All rights reserved.
Re-printed with permission from the NORTH CAROLINA FAMILY COUNCIL MAGAZINE PUBLICATION.
Originally printed – "The Silent Killer: An Argument Against Euthanasia." Family NC, Winter 2010.


text:
Creating A Stunning 3-D Map of the Universe
Creating A 3-D Map of the Universe
Going Back 11 Billion Years
Nearly 500 scientists from 13 countries have come together in an ambitious new effort to map… well, pretty much everything.
As part of a $70 million program funded mostly by the U.S. Department of Energy, the scientists have converted an old telescope in Arizona into a high-tech new sensor that can detect light from stars as far as 11 billion light years away.
The objects, as they appear on Earth, are as old as 11 billion years and offer a tantalizing glimpse into the early eons of our roughly 14-billion-year-old universe.
The data from the Dark Energy Spectroscopic Instrument telescope, situated at Kitt Peak National Observatory around 50 miles southwest of Tucson, could help scientists to build a 3-D map of no fewer than 35 million galaxies comprising around half of the observable universe.
"We will be making a 3D map of the universe going back 11 billion years," Michael Levi, DESI project director, told The Daily Beast.
The whole point of this epic feat of stellar cartography is to try to understand why the universe keeps expanding as quickly as it appears to be doing. The answer to that question could upend our conception of how the universe works.
"The 3-D map will be so precise that we will be able to see the details of the expansion history," Levi explained. "Cosmologists once though that the universe might collapse in on itself, but an unseen energy is driving the universe apart at an accelerating rate. We should be able to see this phenomenon when it turned on in the early history."
3D Map your ideas
The 3D Map Generators are Photoshop plugins that makes it possible to generate 3D maps very fast and dead easy. The result is really professional but doesn't require any advanced Photoshop knowledge.
As a basis there can be used every vector shape, text, pixel or smart object. For the new 3D Map Generator – Terrain can be used every grayscale height map! The generated maps are ready to be designed individually and can be edited at any time.
Afterwards you can add lawn (grass), sand, snow, desert, text, symbols, 2D maps (e.g. Google maps) or an individual texture to the surface of the map. You can draw in streets, routes, lakes, rivers and other kind of waters. With the 3D Map Generator GEO it's even possible to generate real heights and depths on the surface to picture mountains, valleys and other topographic elevations and depressions.
Color and structure of the maps side surface can be changed and edited easily. It's possible to define lights and shadows and to edit them whenever it's needed. The maps have no limit in size and height and can be printed without any problems.
There are different textures, presets and brushes available to design your map, additionally to the tons of icons and elements that are matched perfectly to the 3D map. The generated maps as well as the additional icons have an isometric orientation. Because of this fact it's no problem to use icons made by yourself or purchased from other providers.
You can use the 3D maps for location plans, infographics, presentations, mobile games, map reproductions, weather maps, descriptions of hotel resorts, sport and recreational facility, construction and traffic planning and much more.
System requirements and versions
The 3D Map Generator plugins are independent from language versions and compatible with Photoshop installations as well on Mac as on PC.
The 3D Map Generator 2 can also be used as an action set from Photoshop CS4 upwards. The 3D Map Generator 2 plugin as available from Photoshop CS6 and higher respectively with all features and together with the 3D Map Generator GEO from CC 2014.
All basic descriptions of functions and installations are available as PDF guides and video tutorials. Of course we will help you as well with personal support. Please note that it is important to send the request from our shop site on Envato.
As the pioneers of the 3D Map Generator we guarantee best products. The described functions and the Photoshop and systems compatibilities are tested several times and affirmed by consistently positive customers feedback (4,9/5 stars). We offer every product update for free.
3-D Map Generator
PrevPreviousThe Anatomy of Plants Illustrated Plates
NextHealth Benefits of GingerNext
HOME – Breathtaking footage by Yann Arthus-Bertrand
HOME The film HOME by Yann Arthus-Bertrand is a beautifully shot panorama of the Earth and the damage done to it by modern humanity. It includes a moving narration about the evolution of the Earth, nature, agriculture, humans, and the
Thrive: The Cringeworthy Doc about What's really going on in our world?
Thrive Loaded with breathtaking footage, this documentary, Thrive, brings to light what's really going on in our world. Obviously the universe has the astonishing ability to maintain balance and to thrive. Just think about the miracle of human reproduction that
1 thought on "Creating A Stunning 3-D Map of the Universe"
Yvonne Ruster
I am going to try this 3D map. Been looking for this. Thanks.

redpajama_set_name: RedPajamaCommonCrawl


The Detroit Auto Dealers Association (DADA) Charitable Foundation Fund supports grants to charitable organizations that make a lasting impact on the lives of children and youth in southeast Michigan.
The DADA Charitable Foundation Fund provides support to nonprofit organizations in Wayne, Oakland, Macomb, Washtenaw, St. Clair, Monroe and Livingston counties, with a primary focus on charitable organizations and activities that assist children and youth. The fund is supported by proceeds from the North American International Auto Show Charity Preview.
Since its inception in 1999, the DADA Charitable Foundation Fund has provided more than $6.1 million to support nonprofit organizations that are improving the lives of children and youth in southeast Michigan. This partnership is unique among auto trade associations nationally — a permanent legacy to benefit our region for generations to come.
Any 501(c)(3) nonprofit organization in southeast Michigan may apply for a grant. Southeast Michigan is defined as the seven counties of Wayne, Oakland, Macomb, Monroe, Washtenaw, St. Clair and Livingston. The 7 nonprofit organizations that traditionally receive support directly from the Charity Preview are ineligible. Please note that the Fund does not award grants to host or sponsor events.


text:
package eviction

import (
	"fmt"
	"reflect"
	"testing"
	"time"

	"k8s.io/api/core/v1"
	"k8s.io/apimachinery/pkg/api/resource"
	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
	"k8s.io/apimachinery/pkg/types"
	"k8s.io/kubernetes/pkg/api"
	statsapi "k8s.io/kubernetes/pkg/kubelet/apis/stats/v1alpha1"
	"k8s.io/kubernetes/pkg/kubelet/cm"
	evictionapi "k8s.io/kubernetes/pkg/kubelet/eviction/api"
	"k8s.io/kubernetes/pkg/quota"
)

func quantityMustParse(value string) *resource.Quantity {
	q := resource.MustParse(value)
	return &q
}

func TestParseThresholdConfig(t *testing.T) {
	gracePeriod, _ := time.ParseDuration("30s")
	testCases := map[string]struct {
		allocatableConfig       []string
		evictionHard            string
		evictionSoft            string
		evictionSoftGracePeriod string
		evictionMinReclaim      string
		expectErr               bool
		expectThresholds        []evictionapi.Threshold
	}{
		"no values": {
			allocatableConfig:       []string{},
			evictionHard:            "",
			evictionSoft:            "",
			evictionSoftGracePeriod: "",
			evictionMinReclaim:      "",
			expectErr:               false,
			expectThresholds:        []evictionapi.Threshold{},
		},
		"all flag values": {
			allocatableConfig:       []string{cm.NodeAllocatableEnforcementKey},
			evictionHard:            "memory.available<150Mi",
			evictionSoft:            "memory.available<300Mi",
			evictionSoftGracePeriod: "memory.available=30s",
			evictionMinReclaim:      "memory.available=0",
			expectErr:               false,
			expectThresholds: []evictionapi.Threshold{
				{
					Signal:   evictionapi.SignalAllocatableMemoryAvailable,
					Operator: evictionapi.OpLessThan,
					Value: evictionapi.ThresholdValue{
						Quantity: quantityMustParse("0"),
					},
					MinReclaim: &evictionapi.ThresholdValue{
						Quantity: quantityMustParse("0"),
					},
				},
				{
					Signal:   evictionapi.SignalAllocatableNodeFsAvailable,
					Operator: evictionapi.OpLessThan,
					Value: evictionapi.ThresholdValue{
						Quantity: quantityMustParse("0"),
					},
					MinReclaim: &evictionapi.ThresholdValue{
						Quantity: quantityMustParse("0"),
					},
				},
				{
					Signal:   evictionapi.SignalMemoryAvailable,
					Operator: evictionapi.OpLessThan,
					Value: evictionapi.ThresholdValue{
						Quantity: quantityMustParse("150Mi"),
					},
					MinReclaim: &evictionapi.ThresholdValue{
						Quantity: quantityMustParse("0"),
					},
				},
				{
					Signal:   evictionapi.SignalMemoryAvailable,
					Operator: evictionapi.OpLessThan,
					Value: evictionapi.ThresholdValue{
						Quantity: quantityMustParse("300Mi"),
					},
					GracePeriod: gracePeriod,
					MinReclaim: &evictionapi.ThresholdValue{
						Quantity: quantityMustParse("0"),
					},
				},
			},
		},
		"all flag values in percentages": {
			allocatableConfig:       []string{},
			evictionHard:            "memory.available<10%",
			evictionSoft:            "memory.available<30%",
			evictionSoftGracePeriod: "memory.available=30s",
			evictionMinReclaim:      "memory.available=5%",
			expectErr:               false,
			expectThresholds: []evictionapi.Threshold{
				{
					Signal:   evictionapi.SignalMemoryAvailable,
					Operator: evictionapi.OpLessThan,
					Value: evictionapi.ThresholdValue{
						Percentage: 0.1,
					},
					MinReclaim: &evictionapi.ThresholdValue{
						Percentage: 0.05,
					},
				},
				{
					Signal:   evictionapi.SignalMemoryAvailable,
					Operator: evictionapi.OpLessThan,
					Value: evictionapi.ThresholdValue{
						Percentage: 0.3,
					},
					GracePeriod: gracePeriod,
					MinReclaim: &evictionapi.ThresholdValue{
						Percentage: 0.05,
					},
				},
			},
		},
		"disk flag values": {
			allocatableConfig:       []string{},
			evictionHard:            "imagefs.available<150Mi,nodefs.available<100Mi",
			evictionSoft:            "imagefs.available<300Mi,nodefs.available<200Mi",
			evictionSoftGracePeriod: "imagefs.available=30s,nodefs.available=30s",
			evictionMinReclaim:      "imagefs.available=2Gi,nodefs.available=1Gi",
			expectErr:               false,
			expectThresholds: []evictionapi.Threshold{
				{
					Signal:   evictionapi.SignalImageFsAvailable,
					Operator: evictionapi.OpLessThan,
					Value: evictionapi.ThresholdValue{
						Quantity: quantityMustParse("150Mi"),
					},
					MinReclaim: &evictionapi.ThresholdValue{
						Quantity: quantityMustParse("2Gi"),
					},
				},
				{
					Signal:   evictionapi.SignalNodeFsAvailable,
					Operator: evictionapi.OpLessThan,
					Value: evictionapi.ThresholdValue{
						Quantity: quantityMustParse("100Mi"),
					},
					MinReclaim: &evictionapi.ThresholdValue{
						Quantity: quantityMustParse("1Gi"),
					},
				},
				{
					Signal:   evictionapi.SignalImageFsAvailable,
					Operator: evictionapi.OpLessThan,
					Value: evictionapi.ThresholdValue{
						Quantity: quantityMustParse("300Mi"),
					},
					GracePeriod: gracePeriod,
					MinReclaim: &evictionapi.ThresholdValue{
						Quantity: quantityMustParse("2Gi"),
					},
				},
				{
					Signal:   evictionapi.SignalNodeFsAvailable,
					Operator: evictionapi.OpLessThan,
					Value: evictionapi.ThresholdValue{
						Quantity: quantityMustParse("200Mi"),
					},
					GracePeriod: gracePeriod,
					MinReclaim: &evictionapi.ThresholdValue{
						Quantity: quantityMustParse("1Gi"),
					},
				},
			},
		},
		"disk flag values in percentages": {
			allocatableConfig:       []string{},
			evictionHard:            "imagefs.available<15%,nodefs.available<10.5%",
			evictionSoft:            "imagefs.available<30%,nodefs.available<20.5%",
			evictionSoftGracePeriod: "imagefs.available=30s,nodefs.available=30s",
			evictionMinReclaim:      "imagefs.available=10%,nodefs.available=5%",
			expectErr:               false,
			expectThresholds: []evictionapi.Threshold{
				{
					Signal:   evictionapi.SignalImageFsAvailable,
					Operator: evictionapi.OpLessThan,
					Value: evictionapi.ThresholdValue{
						Percentage: 0.15,
					},
					MinReclaim: &evictionapi.ThresholdValue{
						Percentage: 0.1,
					},
				},
				{
					Signal:   evictionapi.SignalNodeFsAvailable,
					Operator: evictionapi.OpLessThan,
					Value: evictionapi.ThresholdValue{
						Percentage: 0.105,
					},
					MinReclaim: &evictionapi.ThresholdValue{
						Percentage: 0.05,
					},
				},
				{
					Signal:   evictionapi.SignalImageFsAvailable,
					Operator: evictionapi.OpLessThan,
					Value: evictionapi.ThresholdValue{
						Percentage: 0.3,
					},
					GracePeriod: gracePeriod,
					MinReclaim: &evictionapi.ThresholdValue{
						Percentage: 0.1,
					},
				},
				{
					Signal:   evictionapi.SignalNodeFsAvailable,
					Operator: evictionapi.OpLessThan,
					Value: evictionapi.ThresholdValue{
						Percentage: 0.205,
					},
					GracePeriod: gracePeriod,
					MinReclaim: &evictionapi.ThresholdValue{
						Percentage: 0.05,
					},
				},
			},
		},
		"inode flag values": {
			allocatableConfig:       []string{},
			evictionHard:            "imagefs.inodesFree<150Mi,nodefs.inodesFree<100Mi",
			evictionSoft:            "imagefs.inodesFree<300Mi,nodefs.inodesFree<200Mi",
			evictionSoftGracePeriod: "imagefs.inodesFree=30s,nodefs.inodesFree=30s",
			evictionMinReclaim:      "imagefs.inodesFree=2Gi,nodefs.inodesFree=1Gi",
			expectErr:               false,
			expectThresholds: []evictionapi.Threshold{
				{
					Signal:   evictionapi.SignalImageFsInodesFree,
					Operator: evictionapi.OpLessThan,
					Value: evictionapi.ThresholdValue{
						Quantity: quantityMustParse("150Mi"),
					},
					MinReclaim: &evictionapi.ThresholdValue{
						Quantity: quantityMustParse("2Gi"),
					},
				},
				{
					Signal:   evictionapi.SignalNodeFsInodesFree,
					Operator: evictionapi.OpLessThan,
					Value: evictionapi.ThresholdValue{
						Quantity: quantityMustParse("100Mi"),
					},
					MinReclaim: &evictionapi.ThresholdValue{
						Quantity: quantityMustParse("1Gi"),
					},
				},
				{
					Signal:   evictionapi.SignalImageFsInodesFree,
					Operator: evictionapi.OpLessThan,
					Value: evictionapi.ThresholdValue{
						Quantity: quantityMustParse("300Mi"),
					},
					GracePeriod: gracePeriod,
					MinReclaim: &evictionapi.ThresholdValue{
						Quantity: quantityMustParse("2Gi"),
					},
				},
				{
					Signal:   evictionapi.SignalNodeFsInodesFree,
					Operator: evictionapi.OpLessThan,
					Value: evictionapi.ThresholdValue{
						Quantity: quantityMustParse("200Mi"),
					},
					GracePeriod: gracePeriod,
					MinReclaim: &evictionapi.ThresholdValue{
						Quantity: quantityMustParse("1Gi"),
					},
				},
			},
		},
		"invalid-signal": {
			allocatableConfig:       []string{},
			evictionHard:            "mem.available<150Mi",
			evictionSoft:            "",
			evictionSoftGracePeriod: "",
			evictionMinReclaim:      "",
			expectErr:               true,
			expectThresholds:        []evictionapi.Threshold{},
		},
		"hard-signal-negative": {
			allocatableConfig:       []string{},
			evictionHard:            "memory.available<-150Mi",
			evictionSoft:            "",
			evictionSoftGracePeriod: "",
			evictionMinReclaim:      "",
			expectErr:               true,
			expectThresholds:        []evictionapi.Threshold{},
		},
		"hard-signal-negative-percentage": {
			allocatableConfig:       []string{},
			evictionHard:            "memory.available<-15%",
			evictionSoft:            "",
			evictionSoftGracePeriod: "",
			evictionMinReclaim:      "",
			expectErr:               true,
			expectThresholds:        []evictionapi.Threshold{},
		},
		"soft-signal-negative": {
			allocatableConfig:       []string{},
			evictionHard:            "",
			evictionSoft:            "memory.available<-150Mi",
			evictionSoftGracePeriod: "",
			evictionMinReclaim:      "",
			expectErr:               true,
			expectThresholds:        []evictionapi.Threshold{},
		},
		"duplicate-signal": {
			allocatableConfig:       []string{},
			evictionHard:            "memory.available<150Mi,memory.available<100Mi",
			evictionSoft:            "",
			evictionSoftGracePeriod: "",
			evictionMinReclaim:      "",
			expectErr:               true,
			expectThresholds:        []evictionapi.Threshold{},
		},
		"valid-and-invalid-signal": {
			allocatableConfig:       []string{},
			evictionHard:            "memory.available<150Mi,invalid.foo<150Mi",
			evictionSoft:            "",
			evictionSoftGracePeriod: "",
			evictionMinReclaim:      "",
			expectErr:               true,
			expectThresholds:        []evictionapi.Threshold{},
		},
		"soft-no-grace-period": {
			allocatableConfig:       []string{},
			evictionHard:            "",
			evictionSoft:            "memory.available<150Mi",
			evictionSoftGracePeriod: "",
			evictionMinReclaim:      "",
			expectErr:               true,
			expectThresholds:        []evictionapi.Threshold{},
		},
		"soft-neg-grace-period": {
			allocatableConfig:       []string{},
			evictionHard:            "",
			evictionSoft:            "memory.available<150Mi",
			evictionSoftGracePeriod: "memory.available=-30s",
			evictionMinReclaim:      "",
			expectErr:               true,
			expectThresholds:        []evictionapi.Threshold{},
		},
		"neg-reclaim": {
			allocatableConfig:       []string{},
			evictionHard:            "",
			evictionSoft:            "",
			evictionSoftGracePeriod: "",
			evictionMinReclaim:      "memory.available=-300Mi",
			expectErr:               true,
			expectThresholds:        []evictionapi.Threshold{},
		},
		"duplicate-reclaim": {
			allocatableConfig:       []string{},
			evictionHard:            "",
			evictionSoft:            "",
			evictionSoftGracePeriod: "",
			evictionMinReclaim:      "memory.available=-300Mi,memory.available=-100Mi",
			expectErr:               true,
			expectThresholds:        []evictionapi.Threshold{},
		},
	}
	for testName, testCase := range testCases {
		thresholds, err := ParseThresholdConfig(testCase.allocatableConfig, testCase.evictionHard, testCase.evictionSoft, testCase.evictionSoftGracePeriod, testCase.evictionMinReclaim)
		if testCase.expectErr != (err != nil) {
			t.Errorf("Err not as expected, test: %v, error expected: %v, actual: %v", testName, testCase.expectErr, err)
		}
		if !thresholdsEqual(testCase.expectThresholds, thresholds) {
			t.Errorf("thresholds not as expected, test: %v, expected: %v, actual: %v", testName, testCase.expectThresholds, thresholds)
		}
	}
}

func thresholdsEqual(expected []evictionapi.Threshold, actual []evictionapi.Threshold) bool {
	if len(expected) != len(actual) {
		return false
	}
	for _, aThreshold := range expected {
		equal := false
		for _, bThreshold := range actual {
			if thresholdEqual(aThreshold, bThreshold) {
				equal = true
			}
		}
		if !equal {
			return false
		}
	}
	for _, aThreshold := range actual {
		equal := false
		for _, bThreshold := range expected {
			if thresholdEqual(aThreshold, bThreshold) {
				equal = true
			}
		}
		if !equal {
			return false
		}
	}
	return true
}

func thresholdEqual(a evictionapi.Threshold, b evictionapi.Threshold) bool {
	return a.GracePeriod == b.GracePeriod &&
		a.Operator == b.Operator &&
		a.Signal == b.Signal &&
		compareThresholdValue(*a.MinReclaim, *b.MinReclaim) &&
		compareThresholdValue(a.Value, b.Value)
}

// TestOrderedByQoS ensures we order BestEffort < Burstable < Guaranteed
func TestOrderedByQoS(t *testing.T) {
	bestEffort := newPod("best-effort", []v1.Container{
		newContainer("best-effort", newResourceList("", ""), newResourceList("", "")),
	}, nil)
	burstable := newPod("burstable", []v1.Container{
		newContainer("burstable", newResourceList("100m", "100Mi"), newResourceList("200m", "200Mi")),
	}, nil)
	guaranteed := newPod("guaranteed", []v1.Container{
		newContainer("guaranteed", newResourceList("200m", "200Mi"), newResourceList("200m", "200Mi")),
	}, nil)

	pods := []*v1.Pod{guaranteed, burstable, bestEffort}
	orderedBy(qosComparator).Sort(pods)

	expected := []*v1.Pod{bestEffort, burstable, guaranteed}
	for i := range expected {
		if pods[i] != expected[i] {
			t.Errorf("Expected pod: %s, but got: %s", expected[i].Name, pods[i].Name)
		}
	}
}

func TestOrderedbyDisk(t *testing.T) {
	testOrderedByResource(t, resourceDisk, newPodDiskStats)
}

func TestOrderedbyInodes(t *testing.T) {
	testOrderedByResource(t, resourceInodes, newPodInodeStats)
}

// testOrderedByDisk ensures we order pods by greediest resource consumer
func testOrderedByResource(t *testing.T, orderedByResource v1.ResourceName,
	newPodStatsFunc func(pod *v1.Pod, rootFsUsed, logsUsed, perLocalVolumeUsed resource.Quantity) statsapi.PodStats) {
	pod1 := newPod("best-effort-high", []v1.Container{
		newContainer("best-effort-high", newResourceList("", ""), newResourceList("", "")),
	}, []v1.Volume{
		newVolume("local-volume", v1.VolumeSource{
			EmptyDir: &v1.EmptyDirVolumeSource{},
		}),
	})
	pod2 := newPod("best-effort-low", []v1.Container{
		newContainer("best-effort-low", newResourceList("", ""), newResourceList("", "")),
	}, []v1.Volume{
		newVolume("local-volume", v1.VolumeSource{
			EmptyDir: &v1.EmptyDirVolumeSource{},
		}),
	})
	pod3 := newPod("burstable-high", []v1.Container{
		newContainer("burstable-high", newResourceList("100m", "100Mi"), newResourceList("200m", "1Gi")),
	}, []v1.Volume{
		newVolume("local-volume", v1.VolumeSource{
			EmptyDir: &v1.EmptyDirVolumeSource{},
		}),
	})
	pod4 := newPod("burstable-low", []v1.Container{
		newContainer("burstable-low", newResourceList("100m", "100Mi"), newResourceList("200m", "1Gi")),
	}, []v1.Volume{
		newVolume("local-volume", v1.VolumeSource{
			EmptyDir: &v1.EmptyDirVolumeSource{},
		}),
	})
	pod5 := newPod("guaranteed-high", []v1.Container{
		newContainer("guaranteed-high", newResourceList("100m", "1Gi"), newResourceList("100m", "1Gi")),
	}, []v1.Volume{
		newVolume("local-volume", v1.VolumeSource{
			EmptyDir: &v1.EmptyDirVolumeSource{},
		}),
	})
	pod6 := newPod("guaranteed-low", []v1.Container{
		newContainer("guaranteed-low", newResourceList("100m", "1Gi"), newResourceList("100m", "1Gi")),
	}, []v1.Volume{
		newVolume("local-volume", v1.VolumeSource{
			EmptyDir: &v1.EmptyDirVolumeSource{},
		}),
	})
	stats := map[*v1.Pod]statsapi.PodStats{
		pod1: newPodStatsFunc(pod1, resource.MustParse("50Mi"), resource.MustParse("100Mi"), resource.MustParse("50Mi")),  // 200Mi
		pod2: newPodStatsFunc(pod2, resource.MustParse("100Mi"), resource.MustParse("150Mi"), resource.MustParse("50Mi")), // 300Mi
		pod3: newPodStatsFunc(pod3, resource.MustParse("200Mi"), resource.MustParse("150Mi"), resource.MustParse("50Mi")), // 400Mi
		pod4: newPodStatsFunc(pod4, resource.MustParse("300Mi"), resource.MustParse("100Mi"), resource.MustParse("50Mi")), // 450Mi
		pod5: newPodStatsFunc(pod5, resource.MustParse("400Mi"), resource.MustParse("100Mi"), resource.MustParse("50Mi")), // 550Mi
		pod6: newPodStatsFunc(pod6, resource.MustParse("500Mi"), resource.MustParse("100Mi"), resource.MustParse("50Mi")), // 650Mi
	}
	statsFn := func(pod *v1.Pod) (statsapi.PodStats, bool) {
		result, found := stats[pod]
		return result, found
	}
	pods := []*v1.Pod{pod1, pod2, pod3, pod4, pod5, pod6}
	orderedBy(disk(statsFn, []fsStatsType{fsStatsRoot, fsStatsLogs, fsStatsLocalVolumeSource}, orderedByResource)).Sort(pods)
	expected := []*v1.Pod{pod6, pod5, pod4, pod3, pod2, pod1}
	for i := range expected {
		if pods[i] != expected[i] {
			t.Errorf("Expected pod[%d]: %s, but got: %s", i, expected[i].Name, pods[i].Name)
		}
	}
}

func TestOrderedbyQoSDisk(t *testing.T) {
	testOrderedByQoSResource(t, resourceDisk, newPodDiskStats)
}

func TestOrderedbyQoSInodes(t *testing.T) {
	testOrderedByQoSResource(t, resourceInodes, newPodInodeStats)
}

// testOrderedByQoSDisk ensures we order pods by qos and then greediest resource consumer
func testOrderedByQoSResource(t *testing.T, orderedByResource v1.ResourceName,
	newPodStatsFunc func(pod *v1.Pod, rootFsUsed, logsUsed, perLocalVolumeUsed resource.Quantity) statsapi.PodStats) {
	pod1 := newPod("best-effort-high", []v1.Container{
		newContainer("best-effort-high", newResourceList("", ""), newResourceList("", "")),
	}, []v1.Volume{
		newVolume("local-volume", v1.VolumeSource{
			EmptyDir: &v1.EmptyDirVolumeSource{},
		}),
	})
	pod2 := newPod("best-effort-low", []v1.Container{
		newContainer("best-effort-low", newResourceList("", ""), newResourceList("", "")),
	}, []v1.Volume{
		newVolume("local-volume", v1.VolumeSource{
			EmptyDir: &v1.EmptyDirVolumeSource{},
		}),
	})
	pod3 := newPod("burstable-high", []v1.Container{
		newContainer("burstable-high", newResourceList("100m", "100Mi"), newResourceList("200m", "1Gi")),
	}, []v1.Volume{
		newVolume("local-volume", v1.VolumeSource{
			EmptyDir: &v1.EmptyDirVolumeSource{},
		}),
	})
	pod4 := newPod("burstable-low", []v1.Container{
		newContainer("burstable-low", newResourceList("100m", "100Mi"), newResourceList("200m", "1Gi")),
	}, []v1.Volume{
		newVolume("local-volume", v1.VolumeSource{
			EmptyDir: &v1.EmptyDirVolumeSource{},
		}),
	})
	pod5 := newPod("guaranteed-high", []v1.Container{
		newContainer("guaranteed-high", newResourceList("100m", "1Gi"), newResourceList("100m", "1Gi")),
	}, []v1.Volume{
		newVolume("local-volume", v1.VolumeSource{
			EmptyDir: &v1.EmptyDirVolumeSource{},
		}),
	})
	pod6 := newPod("guaranteed-low", []v1.Container{
		newContainer("guaranteed-low", newResourceList("100m", "1Gi"), newResourceList("100m", "1Gi")),
	}, []v1.Volume{
		newVolume("local-volume", v1.VolumeSource{
			EmptyDir: &v1.EmptyDirVolumeSource{},
		}),
	})
	stats := map[*v1.Pod]statsapi.PodStats{
		pod1: newPodStatsFunc(pod1, resource.MustParse("50Mi"), resource.MustParse("100Mi"), resource.MustParse("50Mi")),  // 200Mi
		pod2: newPodStatsFunc(pod2, resource.MustParse("100Mi"), resource.MustParse("150Mi"), resource.MustParse("50Mi")), // 300Mi
		pod3: newPodStatsFunc(pod3, resource.MustParse("200Mi"), resource.MustParse("150Mi"), resource.MustParse("50Mi")), // 400Mi
		pod4: newPodStatsFunc(pod4, resource.MustParse("300Mi"), resource.MustParse("100Mi"), resource.MustParse("50Mi")), // 450Mi
		pod5: newPodStatsFunc(pod5, resource.MustParse("400Mi"), resource.MustParse("100Mi"), resource.MustParse("50Mi")), // 550Mi
		pod6: newPodStatsFunc(pod6, resource.MustParse("500Mi"), resource.MustParse("100Mi"), resource.MustParse("50Mi")), // 650Mi
	}
	statsFn := func(pod *v1.Pod) (statsapi.PodStats, bool) {
		result, found := stats[pod]
		return result, found
	}
	pods := []*v1.Pod{pod1, pod2, pod3, pod4, pod5, pod6}
	orderedBy(qosComparator, disk(statsFn, []fsStatsType{fsStatsRoot, fsStatsLogs, fsStatsLocalVolumeSource}, orderedByResource)).Sort(pods)
	expected := []*v1.Pod{pod2, pod1, pod4, pod3, pod6, pod5}
	for i := range expected {
		if pods[i] != expected[i] {
			t.Errorf("Expected pod[%d]: %s, but got: %s", i, expected[i].Name, pods[i].Name)
		}
	}
}

// TestOrderedByMemory ensures we order pods by greediest memory consumer relative to request.
func TestOrderedByMemory(t *testing.T) {
	pod1 := newPod("best-effort-high", []v1.Container{
		newContainer("best-effort-high", newResourceList("", ""), newResourceList("", "")),
	}, nil)
	pod2 := newPod("best-effort-low", []v1.Container{
		newContainer("best-effort-low", newResourceList("", ""), newResourceList("", "")),
	}, nil)
	pod3 := newPod("burstable-high", []v1.Container{
		newContainer("burstable-high", newResourceList("100m", "100Mi"), newResourceList("200m", "1Gi")),
	}, nil)
	pod4 := newPod("burstable-low", []v1.Container{
		newContainer("burstable-low", newResourceList("100m", "100Mi"), newResourceList("200m", "1Gi")),
	}, nil)
	pod5 := newPod("guaranteed-high", []v1.Container{
		newContainer("guaranteed-high", newResourceList("100m", "1Gi"), newResourceList("100m", "1Gi")),
	}, nil)
	pod6 := newPod("guaranteed-low", []v1.Container{
		newContainer("guaranteed-low", newResourceList("100m", "1Gi"), newResourceList("100m", "1Gi")),
	}, nil)
	stats := map[*v1.Pod]statsapi.PodStats{
		pod1: newPodMemoryStats(pod1, resource.MustParse("500Mi")), // 500 relative to request
		pod2: newPodMemoryStats(pod2, resource.MustParse("300Mi")), // 300 relative to request
		pod3: newPodMemoryStats(pod3, resource.MustParse("800Mi")), // 700 relative to request
		pod4: newPodMemoryStats(pod4, resource.MustParse("300Mi")), // 200 relative to request
		pod5: newPodMemoryStats(pod5, resource.MustParse("800Mi")), // -200 relative to request
		pod6: newPodMemoryStats(pod6, resource.MustParse("200Mi")), // -800 relative to request
	}
	statsFn := func(pod *v1.Pod) (statsapi.PodStats, bool) {
		result, found := stats[pod]
		return result, found
	}
	pods := []*v1.Pod{pod1, pod2, pod3, pod4, pod5, pod6}
	orderedBy(memory(statsFn)).Sort(pods)
	expected := []*v1.Pod{pod3, pod1, pod2, pod4, pod5, pod6}
	for i := range expected {
		if pods[i] != expected[i] {
			t.Errorf("Expected pod[%d]: %s, but got: %s", i, expected[i].Name, pods[i].Name)
		}
	}
}

// TestOrderedByQoSMemory ensures we order by qosComparator and then memory consumption relative to request.
func TestOrderedByQoSMemory(t *testing.T) {
	pod1 := newPod("best-effort-high", []v1.Container{
		newContainer("best-effort-high", newResourceList("", ""), newResourceList("", "")),
	}, nil)
	pod2 := newPod("best-effort-low", []v1.Container{
		newContainer("best-effort-low", newResourceList("", ""), newResourceList("", "")),
	}, nil)
	pod3 := newPod("burstable-high", []v1.Container{
		newContainer("burstable-high", newResourceList("100m", "100Mi"), newResourceList("200m", "1Gi")),
	}, nil)
	pod4 := newPod("burstable-low", []v1.Container{
		newContainer("burstable-low", newResourceList("100m", "100Mi"), newResourceList("200m", "1Gi")),
	}, nil)
	pod5 := newPod("guaranteed-high", []v1.Container{
		newContainer("guaranteed-high", newResourceList("100m", "1Gi"), newResourceList("100m", "1Gi")),
	}, nil)
	pod6 := newPod("guaranteed-low", []v1.Container{
		newContainer("guaranteed-low", newResourceList("100m", "1Gi"), newResourceList("100m", "1Gi")),
	}, nil)
	stats := map[*v1.Pod]statsapi.PodStats{
		pod1: newPodMemoryStats(pod1, resource.MustParse("500Mi")), // 500 relative to request
		pod2: newPodMemoryStats(pod2, resource.MustParse("50Mi")),  // 50 relative to request
		pod3: newPodMemoryStats(pod3, resource.MustParse("50Mi")),  // -50 relative to request
		pod4: newPodMemoryStats(pod4, resource.MustParse("300Mi")), // 200 relative to request
		pod5: newPodMemoryStats(pod5, resource.MustParse("800Mi")), // -200 relative to request
		pod6: newPodMemoryStats(pod6, resource.MustParse("200Mi")), // -800 relative to request
	}
	statsFn := func(pod *v1.Pod) (statsapi.PodStats, bool) {
		result, found := stats[pod]
		return result, found
	}
	pods := []*v1.Pod{pod1, pod2, pod3, pod4, pod5, pod6}
	expected := []*v1.Pod{pod1, pod2, pod4, pod3, pod5, pod6}
	orderedBy(qosComparator, memory(statsFn)).Sort(pods)
	for i := range expected {
		if pods[i] != expected[i] {
			t.Errorf("Expected pod[%d]: %s, but got: %s", i, expected[i].Name, pods[i].Name)
		}
	}
}

type fakeSummaryProvider struct {
	result *statsapi.Summary
}

func (f *fakeSummaryProvider) Get() (*statsapi.Summary, error) {
	return f.result, nil
}

// newPodStats returns a pod stat where each container is using the specified working set
// each pod must have a Name, UID, Namespace
func newPodStats(pod *v1.Pod, containerWorkingSetBytes int64) statsapi.PodStats {
	result := statsapi.PodStats{
		PodRef: statsapi.PodReference{
			Name:      pod.Name,
			Namespace: pod.Namespace,
			UID:       string(pod.UID),
		},
	}
	val := uint64(containerWorkingSetBytes)
	for range pod.Spec.Containers {
		result.Containers = append(result.Containers, statsapi.ContainerStats{
			Memory: &statsapi.MemoryStats{
				WorkingSetBytes: &val,
			},
		})
	}
	return result
}

func TestMakeSignalObservations(t *testing.T) {
	podMaker := func(name, namespace, uid string, numContainers int) *v1.Pod {
		pod := &v1.Pod{}
		pod.Name = name
		pod.Namespace = namespace
		pod.UID = types.UID(uid)
		pod.Spec = v1.PodSpec{}
		for i := 0; i < numContainers; i++ {
			pod.Spec.Containers = append(pod.Spec.Containers, v1.Container{
				Name: fmt.Sprintf("ctr%v", i),
			})
		}
		return pod
	}
	nodeAvailableBytes := uint64(1024 * 1024 * 1024)
	nodeWorkingSetBytes := uint64(1024 * 1024 * 1024)
	allocatableMemoryCapacity := uint64(5 * 1024 * 1024 * 1024)
	imageFsAvailableBytes := uint64(1024 * 1024)
	imageFsCapacityBytes := uint64(1024 * 1024 * 2)
	nodeFsAvailableBytes := uint64(1024)
	nodeFsCapacityBytes := uint64(1024 * 2)
	imageFsInodesFree := uint64(1024)
	imageFsInodes := uint64(1024 * 1024)
	nodeFsInodesFree := uint64(1024)
	nodeFsInodes := uint64(1024 * 1024)
	fakeStats := &statsapi.Summary{
		Node: statsapi.NodeStats{
			Memory: &statsapi.MemoryStats{
				AvailableBytes:  &nodeAvailableBytes,
				WorkingSetBytes: &nodeWorkingSetBytes,
			},
			Runtime: &statsapi.RuntimeStats{
				ImageFs: &statsapi.FsStats{
					AvailableBytes: &imageFsAvailableBytes,
					CapacityBytes:  &imageFsCapacityBytes,
					InodesFree:     &imageFsInodesFree,
					Inodes:         &imageFsInodes,
				},
			},
			Fs: &statsapi.FsStats{
				AvailableBytes: &nodeFsAvailableBytes,
				CapacityBytes:  &nodeFsCapacityBytes,
				InodesFree:     &nodeFsInodesFree,
				Inodes:         &nodeFsInodes,
			},
		},
		Pods: []statsapi.PodStats{},
	}
	provider := &fakeSummaryProvider{
		result: fakeStats,
	}
	pods := []*v1.Pod{
		podMaker("pod1", "ns1", "uuid1", 1),
		podMaker("pod1", "ns2", "uuid2", 1),
		podMaker("pod3", "ns3", "uuid3", 1),
	}
	containerWorkingSetBytes := int64(1024 * 1024 * 1024)
	for _, pod := range pods {
		fakeStats.Pods = append(fakeStats.Pods, newPodStats(pod, containerWorkingSetBytes))
	}
	res := quantityMustParse("5Gi")
	nodeProvider := newMockNodeProvider(v1.ResourceList{v1.ResourceMemory: *res})
	// Allocatable thresholds are always 100%.  Verify that Threshold == Capacity.
	if res.CmpInt64(int64(allocatableMemoryCapacity)) != 0 {
		t.Errorf("Expected Threshold %v to be equal to value %v", res.Value(), allocatableMemoryCapacity)
	}
	actualObservations, statsFunc, err := makeSignalObservations(provider, nodeProvider, pods, false)
	if err != nil {
		t.Errorf("Unexpected err: %v", err)
	}
	allocatableMemQuantity, found := actualObservations[evictionapi.SignalAllocatableMemoryAvailable]
	if !found {
		t.Errorf("Expected allocatable memory observation, but didnt find one")
	}
	if allocatableMemQuantity.available.Value() != 2*containerWorkingSetBytes {
		t.Errorf("Expected %v, actual: %v", containerWorkingSetBytes, allocatableMemQuantity.available.Value())
	}
	if expectedBytes := int64(allocatableMemoryCapacity); allocatableMemQuantity.capacity.Value() != expectedBytes {
		t.Errorf("Expected %v, actual: %v", expectedBytes, allocatableMemQuantity.capacity.Value())
	}
	memQuantity, found := actualObservations[evictionapi.SignalMemoryAvailable]
	if !found {
		t.Errorf("Expected available memory observation: %v", err)
	}
	if expectedBytes := int64(nodeAvailableBytes); memQuantity.available.Value() != expectedBytes {
		t.Errorf("Expected %v, actual: %v", expectedBytes, memQuantity.available.Value())
	}
	if expectedBytes := int64(nodeWorkingSetBytes + nodeAvailableBytes); memQuantity.capacity.Value() != expectedBytes {
		t.Errorf("Expected %v, actual: %v", expectedBytes, memQuantity.capacity.Value())
	}
	nodeFsQuantity, found := actualObservations[evictionapi.SignalNodeFsAvailable]
	if !found {
		t.Errorf("Expected available nodefs observation: %v", err)
	}
	if expectedBytes := int64(nodeFsAvailableBytes); nodeFsQuantity.available.Value() != expectedBytes {
		t.Errorf("Expected %v, actual: %v", expectedBytes, nodeFsQuantity.available.Value())
	}
	if expectedBytes := int64(nodeFsCapacityBytes); nodeFsQuantity.capacity.Value() != expectedBytes {
		t.Errorf("Expected %v, actual: %v", expectedBytes, nodeFsQuantity.capacity.Value())
	}
	nodeFsInodesQuantity, found := actualObservations[evictionapi.SignalNodeFsInodesFree]
	if !found {
		t.Errorf("Expected inodes free nodefs observation: %v", err)
	}
	if expected := int64(nodeFsInodesFree); nodeFsInodesQuantity.available.Value() != expected {
		t.Errorf("Expected %v, actual: %v", expected, nodeFsInodesQuantity.available.Value())
	}
	if expected := int64(nodeFsInodes); nodeFsInodesQuantity.capacity.Value() != expected {
		t.Errorf("Expected %v, actual: %v", expected, nodeFsInodesQuantity.capacity.Value())
	}
	imageFsQuantity, found := actualObservations[evictionapi.SignalImageFsAvailable]
	if !found {
		t.Errorf("Expected available imagefs observation: %v", err)
	}
	if expectedBytes := int64(imageFsAvailableBytes); imageFsQuantity.available.Value() != expectedBytes {
		t.Errorf("Expected %v, actual: %v", expectedBytes, imageFsQuantity.available.Value())
	}
	if expectedBytes := int64(imageFsCapacityBytes); imageFsQuantity.capacity.Value() != expectedBytes {
		t.Errorf("Expected %v, actual: %v", expectedBytes, imageFsQuantity.capacity.Value())
	}
	imageFsInodesQuantity, found := actualObservations[evictionapi.SignalImageFsInodesFree]
	if !found {
		t.Errorf("Expected inodes free imagefs observation: %v", err)
	}
	if expected := int64(imageFsInodesFree); imageFsInodesQuantity.available.Value() != expected {
		t.Errorf("Expected %v, actual: %v", expected, imageFsInodesQuantity.available.Value())
	}
	if expected := int64(imageFsInodes); imageFsInodesQuantity.capacity.Value() != expected {
		t.Errorf("Expected %v, actual: %v", expected, imageFsInodesQuantity.capacity.Value())
	}
	for _, pod := range pods {
		podStats, found := statsFunc(pod)
		if !found {
			t.Errorf("Pod stats were not found for pod %v", pod.UID)
		}
		for _, container := range podStats.Containers {
			actual := int64(*container.Memory.WorkingSetBytes)
			if containerWorkingSetBytes != actual {
				t.Errorf("Container working set expected %v, actual: %v", containerWorkingSetBytes, actual)
			}
		}
	}
}

func TestThresholdsMet(t *testing.T) {
	hardThreshold := evictionapi.Threshold{
		Signal:   evictionapi.SignalMemoryAvailable,
		Operator: evictionapi.OpLessThan,
		Value: evictionapi.ThresholdValue{
			Quantity: quantityMustParse("1Gi"),
		},
		MinReclaim: &evictionapi.ThresholdValue{
			Quantity: quantityMustParse("500Mi"),
		},
	}
	testCases := map[string]struct {
		enforceMinReclaim bool
		thresholds        []evictionapi.Threshold
		observations      signalObservations
		result            []evictionapi.Threshold
	}{
		"empty": {
			enforceMinReclaim: false,
			thresholds:        []evictionapi.Threshold{},
			observations:      signalObservations{},
			result:            []evictionapi.Threshold{},
		},
		"threshold-met-memory": {
			enforceMinReclaim: false,
			thresholds:        []evictionapi.Threshold{hardThreshold},
			observations: signalObservations{
				evictionapi.SignalMemoryAvailable: signalObservation{
					available: quantityMustParse("500Mi"),
				},
			},
			result: []evictionapi.Threshold{hardThreshold},
		},
		"threshold-not-met": {
			enforceMinReclaim: false,
			thresholds:        []evictionapi.Threshold{hardThreshold},
			observations: signalObservations{
				evictionapi.SignalMemoryAvailable: signalObservation{
					available: quantityMustParse("2Gi"),
				},
			},
			result: []evictionapi.Threshold{},
		},
		"threshold-met-with-min-reclaim": {
			enforceMinReclaim: true,
			thresholds:        []evictionapi.Threshold{hardThreshold},
			observations: signalObservations{
				evictionapi.SignalMemoryAvailable: signalObservation{
					available: quantityMustParse("1.05Gi"),
				},
			},
			result: []evictionapi.Threshold{hardThreshold},
		},
		"threshold-not-met-with-min-reclaim": {
			enforceMinReclaim: true,
			thresholds:        []evictionapi.Threshold{hardThreshold},
			observations: signalObservations{
				evictionapi.SignalMemoryAvailable: signalObservation{
					available: quantityMustParse("2Gi"),
				},
			},
			result: []evictionapi.Threshold{},
		},
	}
	for testName, testCase := range testCases {
		actual := thresholdsMet(testCase.thresholds, testCase.observations, testCase.enforceMinReclaim)
		if !thresholdList(actual).Equal(thresholdList(testCase.result)) {
			t.Errorf("Test case: %s, expected: %v, actual: %v", testName, testCase.result, actual)
		}
	}
}

func TestThresholdsUpdatedStats(t *testing.T) {
	updatedThreshold := evictionapi.Threshold{
		Signal: evictionapi.SignalMemoryAvailable,
	}
	locationUTC, err := time.LoadLocation("UTC")
	if err != nil {
		t.Error(err)
		return
	}
	testCases := map[string]struct {
		thresholds   []evictionapi.Threshold
		observations signalObservations
		last         signalObservations
		result       []evictionapi.Threshold
	}{
		"empty": {
			thresholds:   []evictionapi.Threshold{},
			observations: signalObservations{},
			last:         signalObservations{},
			result:       []evictionapi.Threshold{},
		},
		"no-time": {
			thresholds: []evictionapi.Threshold{updatedThreshold},
			observations: signalObservations{
				evictionapi.SignalMemoryAvailable: signalObservation{},
			},
			last:   signalObservations{},
			result: []evictionapi.Threshold{updatedThreshold},
		},
		"no-last-observation": {
			thresholds: []evictionapi.Threshold{updatedThreshold},
			observations: signalObservations{
				evictionapi.SignalMemoryAvailable: signalObservation{
					time: metav1.Date(2016, 1, 1, 0, 0, 0, 0, locationUTC),
				},
			},
			last:   signalObservations{},
			result: []evictionapi.Threshold{updatedThreshold},
		},
		"time-machine": {
			thresholds: []evictionapi.Threshold{updatedThreshold},
			observations: signalObservations{
				evictionapi.SignalMemoryAvailable: signalObservation{
					time: metav1.Date(2016, 1, 1, 0, 0, 0, 0, locationUTC),
				},
			},
			last: signalObservations{
				evictionapi.SignalMemoryAvailable: signalObservation{
					time: metav1.Date(2016, 1, 1, 0, 1, 0, 0, locationUTC),
				},
			},
			result: []evictionapi.Threshold{},
		},
		"same-observation": {
			thresholds: []evictionapi.Threshold{updatedThreshold},
			observations: signalObservations{
				evictionapi.SignalMemoryAvailable: signalObservation{
					time: metav1.Date(2016, 1, 1, 0, 0, 0, 0, locationUTC),
				},
			},
			last: signalObservations{
				evictionapi.SignalMemoryAvailable: signalObservation{
					time: metav1.Date(2016, 1, 1, 0, 0, 0, 0, locationUTC),
				},
			},
			result: []evictionapi.Threshold{},
		},
		"new-observation": {
			thresholds: []evictionapi.Threshold{updatedThreshold},
			observations: signalObservations{
				evictionapi.SignalMemoryAvailable: signalObservation{
					time: metav1.Date(2016, 1, 1, 0, 1, 0, 0, locationUTC),
				},
			},
			last: signalObservations{
				evictionapi.SignalMemoryAvailable: signalObservation{
					time: metav1.Date(2016, 1, 1, 0, 0, 0, 0, locationUTC),
				},
			},
			result: []evictionapi.Threshold{updatedThreshold},
		},
	}
	for testName, testCase := range testCases {
		actual := thresholdsUpdatedStats(testCase.thresholds, testCase.observations, testCase.last)
		if !thresholdList(actual).Equal(thresholdList(testCase.result)) {
			t.Errorf("Test case: %s, expected: %v, actual: %v", testName, testCase.result, actual)
		}
	}
}

func TestPercentageThresholdsMet(t *testing.T) {
	specificThresholds := []evictionapi.Threshold{
		{
			Signal:   evictionapi.SignalMemoryAvailable,
			Operator: evictionapi.OpLessThan,
			Value: evictionapi.ThresholdValue{
				Percentage: 0.2,
			},
			MinReclaim: &evictionapi.ThresholdValue{
				Percentage: 0.05,
			},
		},
		{
			Signal:   evictionapi.SignalNodeFsAvailable,
			Operator: evictionapi.OpLessThan,
			Value: evictionapi.ThresholdValue{
				Percentage: 0.3,
			},
		},
	}

	testCases := map[string]struct {
		enforceMinRelaim bool
		thresholds       []evictionapi.Threshold
		observations     signalObservations
		result           []evictionapi.Threshold
	}{
		"BothMet": {
			enforceMinRelaim: false,
			thresholds:       specificThresholds,
			observations: signalObservations{
				evictionapi.SignalMemoryAvailable: signalObservation{
					available: quantityMustParse("100Mi"),
					capacity:  quantityMustParse("1000Mi"),
				},
				evictionapi.SignalNodeFsAvailable: signalObservation{
					available: quantityMustParse("100Gi"),
					capacity:  quantityMustParse("1000Gi"),
				},
			},
			result: specificThresholds,
		},
		"NoneMet": {
			enforceMinRelaim: false,
			thresholds:       specificThresholds,
			observations: signalObservations{
				evictionapi.SignalMemoryAvailable: signalObservation{
					available: quantityMustParse("300Mi"),
					capacity:  quantityMustParse("1000Mi"),
				},
				evictionapi.SignalNodeFsAvailable: signalObservation{
					available: quantityMustParse("400Gi"),
					capacity:  quantityMustParse("1000Gi"),
				},
			},
			result: []evictionapi.Threshold{},
		},
		"DiskMet": {
			enforceMinRelaim: false,
			thresholds:       specificThresholds,
			observations: signalObservations{
				evictionapi.SignalMemoryAvailable: signalObservation{
					available: quantityMustParse("300Mi"),
					capacity:  quantityMustParse("1000Mi"),
				},
				evictionapi.SignalNodeFsAvailable: signalObservation{
					available: quantityMustParse("100Gi"),
					capacity:  quantityMustParse("1000Gi"),
				},
			},
			result: []evictionapi.Threshold{specificThresholds[1]},
		},
		"MemoryMet": {
			enforceMinRelaim: false,
			thresholds:       specificThresholds,
			observations: signalObservations{
				evictionapi.SignalMemoryAvailable: signalObservation{
					available: quantityMustParse("100Mi"),
					capacity:  quantityMustParse("1000Mi"),
				},
				evictionapi.SignalNodeFsAvailable: signalObservation{
					available: quantityMustParse("400Gi"),
					capacity:  quantityMustParse("1000Gi"),
				},
			},
			result: []evictionapi.Threshold{specificThresholds[0]},
		},
		"MemoryMetWithMinReclaim": {
			enforceMinRelaim: true,
			thresholds:       specificThresholds,
			observations: signalObservations{
				evictionapi.SignalMemoryAvailable: signalObservation{
					available: quantityMustParse("225Mi"),
					capacity:  quantityMustParse("1000Mi"),
				},
			},
			result: []evictionapi.Threshold{specificThresholds[0]},
		},
		"MemoryNotMetWithMinReclaim": {
			enforceMinRelaim: true,
			thresholds:       specificThresholds,
			observations: signalObservations{
				evictionapi.SignalMemoryAvailable: signalObservation{
					available: quantityMustParse("300Mi"),
					capacity:  quantityMustParse("1000Mi"),
				},
			},
			result: []evictionapi.Threshold{},
		},
	}
	for testName, testCase := range testCases {
		actual := thresholdsMet(testCase.thresholds, testCase.observations, testCase.enforceMinRelaim)
		if !thresholdList(actual).Equal(thresholdList(testCase.result)) {
			t.Errorf("Test case: %s, expected: %v, actual: %v", testName, testCase.result, actual)
		}
	}
}

func TestThresholdsFirstObservedAt(t *testing.T) {
	hardThreshold := evictionapi.Threshold{
		Signal:   evictionapi.SignalMemoryAvailable,
		Operator: evictionapi.OpLessThan,
		Value: evictionapi.ThresholdValue{
			Quantity: quantityMustParse("1Gi"),
		},
	}
	now := metav1.Now()
	oldTime := metav1.NewTime(now.Time.Add(-1 * time.Minute))
	testCases := map[string]struct {
		thresholds     []evictionapi.Threshold
		lastObservedAt thresholdsObservedAt
		now            time.Time
		result         thresholdsObservedAt
	}{
		"empty": {
			thresholds:     []evictionapi.Threshold{},
			lastObservedAt: thresholdsObservedAt{},
			now:            now.Time,
			result:         thresholdsObservedAt{},
		},
		"no-previous-observation": {
			thresholds:     []evictionapi.Threshold{hardThreshold},
			lastObservedAt: thresholdsObservedAt{},
			now:            now.Time,
			result: thresholdsObservedAt{
				hardThreshold: now.Time,
			},
		},
		"previous-observation": {
			thresholds: []evictionapi.Threshold{hardThreshold},
			lastObservedAt: thresholdsObservedAt{
				hardThreshold: oldTime.Time,
			},
			now: now.Time,
			result: thresholdsObservedAt{
				hardThreshold: oldTime.Time,
			},
		},
	}
	for testName, testCase := range testCases {
		actual := thresholdsFirstObservedAt(testCase.thresholds, testCase.lastObservedAt, testCase.now)
		if !reflect.DeepEqual(actual, testCase.result) {
			t.Errorf("Test case: %s, expected: %v, actual: %v", testName, testCase.result, actual)
		}
	}
}

func TestThresholdsMetGracePeriod(t *testing.T) {
	now := metav1.Now()
	hardThreshold := evictionapi.Threshold{
		Signal:   evictionapi.SignalMemoryAvailable,
		Operator: evictionapi.OpLessThan,
		Value: evictionapi.ThresholdValue{
			Quantity: quantityMustParse("1Gi"),
		},
	}
	softThreshold := evictionapi.Threshold{
		Signal:   evictionapi.SignalMemoryAvailable,
		Operator: evictionapi.OpLessThan,
		Value: evictionapi.ThresholdValue{
			Quantity: quantityMustParse("2Gi"),
		},
		GracePeriod: 1 * time.Minute,
	}
	oldTime := metav1.NewTime(now.Time.Add(-2 * time.Minute))
	testCases := map[string]struct {
		observedAt thresholdsObservedAt
		now        time.Time
		result     []evictionapi.Threshold
	}{
		"empty": {
			observedAt: thresholdsObservedAt{},
			now:        now.Time,
			result:     []evictionapi.Threshold{},
		},
		"hard-threshold-met": {
			observedAt: thresholdsObservedAt{
				hardThreshold: now.Time,
			},
			now:    now.Time,
			result: []evictionapi.Threshold{hardThreshold},
		},
		"soft-threshold-not-met": {
			observedAt: thresholdsObservedAt{
				softThreshold: now.Time,
			},
			now:    now.Time,
			result: []evictionapi.Threshold{},
		},
		"soft-threshold-met": {
			observedAt: thresholdsObservedAt{
				softThreshold: oldTime.Time,
			},
			now:    now.Time,
			result: []evictionapi.Threshold{softThreshold},
		},
	}
	for testName, testCase := range testCases {
		actual := thresholdsMetGracePeriod(testCase.observedAt, now.Time)
		if !thresholdList(actual).Equal(thresholdList(testCase.result)) {
			t.Errorf("Test case: %s, expected: %v, actual: %v", testName, testCase.result, actual)
		}
	}
}

func TestNodeConditions(t *testing.T) {
	testCases := map[string]struct {
		inputs []evictionapi.Threshold
		result []v1.NodeConditionType
	}{
		"empty-list": {
			inputs: []evictionapi.Threshold{},
			result: []v1.NodeConditionType{},
		},
		"memory.available": {
			inputs: []evictionapi.Threshold{
				{Signal: evictionapi.SignalMemoryAvailable},
			},
			result: []v1.NodeConditionType{v1.NodeMemoryPressure},
		},
	}
	for testName, testCase := range testCases {
		actual := nodeConditions(testCase.inputs)
		if !nodeConditionList(actual).Equal(nodeConditionList(testCase.result)) {
			t.Errorf("Test case: %s, expected: %v, actual: %v", testName, testCase.result, actual)
		}
	}
}

func TestNodeConditionsLastObservedAt(t *testing.T) {
	now := metav1.Now()
	oldTime := metav1.NewTime(now.Time.Add(-1 * time.Minute))
	testCases := map[string]struct {
		nodeConditions []v1.NodeConditionType
		lastObservedAt nodeConditionsObservedAt
		now            time.Time
		result         nodeConditionsObservedAt
	}{
		"no-previous-observation": {
			nodeConditions: []v1.NodeConditionType{v1.NodeMemoryPressure},
			lastObservedAt: nodeConditionsObservedAt{},
			now:            now.Time,
			result: nodeConditionsObservedAt{
				v1.NodeMemoryPressure: now.Time,
			},
		},
		"previous-observation": {
			nodeConditions: []v1.NodeConditionType{v1.NodeMemoryPressure},
			lastObservedAt: nodeConditionsObservedAt{
				v1.NodeMemoryPressure: oldTime.Time,
			},
			now: now.Time,
			result: nodeConditionsObservedAt{
				v1.NodeMemoryPressure: now.Time,
			},
		},
		"old-observation": {
			nodeConditions: []v1.NodeConditionType{},
			lastObservedAt: nodeConditionsObservedAt{
				v1.NodeMemoryPressure: oldTime.Time,
			},
			now: now.Time,
			result: nodeConditionsObservedAt{
				v1.NodeMemoryPressure: oldTime.Time,
			},
		},
	}
	for testName, testCase := range testCases {
		actual := nodeConditionsLastObservedAt(testCase.nodeConditions, testCase.lastObservedAt, testCase.now)
		if !reflect.DeepEqual(actual, testCase.result) {
			t.Errorf("Test case: %s, expected: %v, actual: %v", testName, testCase.result, actual)
		}
	}
}

func TestNodeConditionsObservedSince(t *testing.T) {
	now := metav1.Now()
	observedTime := metav1.NewTime(now.Time.Add(-1 * time.Minute))
	testCases := map[string]struct {
		observedAt nodeConditionsObservedAt
		period     time.Duration
		now        time.Time
		result     []v1.NodeConditionType
	}{
		"in-period": {
			observedAt: nodeConditionsObservedAt{
				v1.NodeMemoryPressure: observedTime.Time,
			},
			period: 2 * time.Minute,
			now:    now.Time,
			result: []v1.NodeConditionType{v1.NodeMemoryPressure},
		},
		"out-of-period": {
			observedAt: nodeConditionsObservedAt{
				v1.NodeMemoryPressure: observedTime.Time,
			},
			period: 30 * time.Second,
			now:    now.Time,
			result: []v1.NodeConditionType{},
		},
	}
	for testName, testCase := range testCases {
		actual := nodeConditionsObservedSince(testCase.observedAt, testCase.period, testCase.now)
		if !nodeConditionList(actual).Equal(nodeConditionList(testCase.result)) {
			t.Errorf("Test case: %s, expected: %v, actual: %v", testName, testCase.result, actual)
		}
	}
}

func TestHasNodeConditions(t *testing.T) {
	testCases := map[string]struct {
		inputs []v1.NodeConditionType
		item   v1.NodeConditionType
		result bool
	}{
		"has-condition": {
			inputs: []v1.NodeConditionType{v1.NodeReady, v1.NodeOutOfDisk, v1.NodeMemoryPressure},
			item:   v1.NodeMemoryPressure,
			result: true,
		},
		"does-not-have-condition": {
			inputs: []v1.NodeConditionType{v1.NodeReady, v1.NodeOutOfDisk},
			item:   v1.NodeMemoryPressure,
			result: false,
		},
	}
	for testName, testCase := range testCases {
		if actual := hasNodeCondition(testCase.inputs, testCase.item); actual != testCase.result {
			t.Errorf("Test case: %s, expected: %v, actual: %v", testName, testCase.result, actual)
		}
	}
}

func TestGetStarvedResources(t *testing.T) {
	testCases := map[string]struct {
		inputs []evictionapi.Threshold
		result []v1.ResourceName
	}{
		"memory.available": {
			inputs: []evictionapi.Threshold{
				{Signal: evictionapi.SignalMemoryAvailable},
			},
			result: []v1.ResourceName{v1.ResourceMemory},
		},
		"imagefs.available": {
			inputs: []evictionapi.Threshold{
				{Signal: evictionapi.SignalImageFsAvailable},
			},
			result: []v1.ResourceName{resourceImageFs},
		},
		"nodefs.available": {
			inputs: []evictionapi.Threshold{
				{Signal: evictionapi.SignalNodeFsAvailable},
			},
			result: []v1.ResourceName{resourceNodeFs},
		},
	}
	var internalResourceNames = func(in []v1.ResourceName) []api.ResourceName {
		var out []api.ResourceName
		for _, name := range in {
			out = append(out, api.ResourceName(name))
		}
		return out
	}
	for testName, testCase := range testCases {
		actual := getStarvedResources(testCase.inputs)
		actualSet := quota.ToSet(internalResourceNames(actual))
		expectedSet := quota.ToSet(internalResourceNames(testCase.result))
		if !actualSet.Equal(expectedSet) {
			t.Errorf("Test case: %s, expected: %v, actual: %v", testName, expectedSet, actualSet)
		}
	}
}

func testParsePercentage(t *testing.T) {
	testCases := map[string]struct {
		hasError bool
		value    float32
	}{
		"blah": {
			hasError: true,
		},
		"25.5%": {
			value: 0.255,
		},
		"foo%": {
			hasError: true,
		},
		"12%345": {
			hasError: true,
		},
	}
	for input, expected := range testCases {
		value, err := parsePercentage(input)
		if (err != nil) != expected.hasError {
			t.Errorf("Test case: %s, expected: %v, actual: %v", input, expected.hasError, err != nil)
		}
		if value != expected.value {
			t.Errorf("Test case: %s, expected: %v, actual: %v", input, expected.value, value)
		}
	}
}

func testCompareThresholdValue(t *testing.T) {
	testCases := []struct {
		a, b  evictionapi.ThresholdValue
		equal bool
	}{
		{
			a: evictionapi.ThresholdValue{
				Quantity: resource.NewQuantity(123, resource.BinarySI),
			},
			b: evictionapi.ThresholdValue{
				Quantity: resource.NewQuantity(123, resource.BinarySI),
			},
			equal: true,
		},
		{
			a: evictionapi.ThresholdValue{
				Quantity: resource.NewQuantity(123, resource.BinarySI),
			},
			b: evictionapi.ThresholdValue{
				Quantity: resource.NewQuantity(456, resource.BinarySI),
			},
			equal: false,
		},
		{
			a: evictionapi.ThresholdValue{
				Quantity: resource.NewQuantity(123, resource.BinarySI),
			},
			b: evictionapi.ThresholdValue{
				Percentage: 0.1,
			},
			equal: false,
		},
		{
			a: evictionapi.ThresholdValue{
				Percentage: 0.1,
			},
			b: evictionapi.ThresholdValue{
				Percentage: 0.1,
			},
			equal: true,
		},
		{
			a: evictionapi.ThresholdValue{
				Percentage: 0.2,
			},
			b: evictionapi.ThresholdValue{
				Percentage: 0.1,
			},
			equal: false,
		},
	}

	for i, testCase := range testCases {
		if compareThresholdValue(testCase.a, testCase.b) != testCase.equal ||
			compareThresholdValue(testCase.b, testCase.a) != testCase.equal {
			t.Errorf("Test case: %v failed", i)
		}
	}
}

// newPodInodeStats returns stats with specified usage amounts.
func newPodInodeStats(pod *v1.Pod, rootFsInodesUsed, logsInodesUsed, perLocalVolumeInodesUsed resource.Quantity) statsapi.PodStats {
	result := statsapi.PodStats{
		PodRef: statsapi.PodReference{
			Name: pod.Name, Namespace: pod.Namespace, UID: string(pod.UID),
		},
	}
	rootFsUsed := uint64(rootFsInodesUsed.Value())
	logsUsed := uint64(logsInodesUsed.Value())
	for range pod.Spec.Containers {
		result.Containers = append(result.Containers, statsapi.ContainerStats{
			Rootfs: &statsapi.FsStats{
				InodesUsed: &rootFsUsed,
			},
			Logs: &statsapi.FsStats{
				InodesUsed: &logsUsed,
			},
		})
	}

	perLocalVolumeUsed := uint64(perLocalVolumeInodesUsed.Value())
	for _, volumeName := range localVolumeNames(pod) {
		result.VolumeStats = append(result.VolumeStats, statsapi.VolumeStats{
			Name: volumeName,
			FsStats: statsapi.FsStats{
				InodesUsed: &perLocalVolumeUsed,
			},
		})
	}
	return result
}

// newPodDiskStats returns stats with specified usage amounts.
func newPodDiskStats(pod *v1.Pod, rootFsUsed, logsUsed, perLocalVolumeUsed resource.Quantity) statsapi.PodStats {
	result := statsapi.PodStats{
		PodRef: statsapi.PodReference{
			Name: pod.Name, Namespace: pod.Namespace, UID: string(pod.UID),
		},
	}

	rootFsUsedBytes := uint64(rootFsUsed.Value())
	logsUsedBytes := uint64(logsUsed.Value())
	for range pod.Spec.Containers {
		result.Containers = append(result.Containers, statsapi.ContainerStats{
			Rootfs: &statsapi.FsStats{
				UsedBytes: &rootFsUsedBytes,
			},
			Logs: &statsapi.FsStats{
				UsedBytes: &logsUsedBytes,
			},
		})
	}

	perLocalVolumeUsedBytes := uint64(perLocalVolumeUsed.Value())
	for _, volumeName := range localVolumeNames(pod) {
		result.VolumeStats = append(result.VolumeStats, statsapi.VolumeStats{
			Name: volumeName,
			FsStats: statsapi.FsStats{
				UsedBytes: &perLocalVolumeUsedBytes,
			},
		})
	}

	return result
}

func newPodMemoryStats(pod *v1.Pod, workingSet resource.Quantity) statsapi.PodStats {
	result := statsapi.PodStats{
		PodRef: statsapi.PodReference{
			Name: pod.Name, Namespace: pod.Namespace, UID: string(pod.UID),
		},
	}
	for range pod.Spec.Containers {
		workingSetBytes := uint64(workingSet.Value())
		result.Containers = append(result.Containers, statsapi.ContainerStats{
			Memory: &statsapi.MemoryStats{
				WorkingSetBytes: &workingSetBytes,
			},
		})
	}
	return result
}

func newResourceList(cpu, memory string) v1.ResourceList {
	res := v1.ResourceList{}
	if cpu != "" {
		res[v1.ResourceCPU] = resource.MustParse(cpu)
	}
	if memory != "" {
		res[v1.ResourceMemory] = resource.MustParse(memory)
	}
	return res
}

func newResourceRequirements(requests, limits v1.ResourceList) v1.ResourceRequirements {
	res := v1.ResourceRequirements{}
	res.Requests = requests
	res.Limits = limits
	return res
}

func newContainer(name string, requests v1.ResourceList, limits v1.ResourceList) v1.Container {
	return v1.Container{
		Name:      name,
		Resources: newResourceRequirements(requests, limits),
	}
}

func newVolume(name string, volumeSource v1.VolumeSource) v1.Volume {
	return v1.Volume{
		Name:         name,
		VolumeSource: volumeSource,
	}
}

// newPod uses the name as the uid.  Make names unique for testing.
func newPod(name string, containers []v1.Container, volumes []v1.Volume) *v1.Pod {
	return &v1.Pod{
		ObjectMeta: metav1.ObjectMeta{
			Name: name,
			UID:  types.UID(name),
		},
		Spec: v1.PodSpec{
			Containers: containers,
			Volumes:    volumes,
		},
	}
}

// nodeConditionList is a simple alias to support equality checking independent of order
type nodeConditionList []v1.NodeConditionType

// Equal adds the ability to check equality between two lists of node conditions.
func (s1 nodeConditionList) Equal(s2 nodeConditionList) bool {
	if len(s1) != len(s2) {
		return false
	}
	for _, item := range s1 {
		if !hasNodeCondition(s2, item) {
			return false
		}
	}
	return true
}

// thresholdList is a simple alias to support equality checking independent of order
type thresholdList []evictionapi.Threshold

// Equal adds the ability to check equality between two lists of node conditions.
func (s1 thresholdList) Equal(s2 thresholdList) bool {
	if len(s1) != len(s2) {
		return false
	}
	for _, item := range s1 {
		if !hasThreshold(s2, item) {
			return false
		}
	}
	return true
}

redpajama_set_name: RedPajamaGithub


text:
Antonio Feliciano de Castilho (ur. 1800, zm. 1875) – portugalski poeta, jeden z głównych reprezentantów romantyzmu.

Życiorys
Antonio Feliciano de Castilho urodził się w Lizbonie 28 stycznia 1800 roku. Był synem lekarza José Feliciana de Castilho i jego żony Domícilii Máximy de Castilho. W wieku sześciu lat stracił wzrok. Życiowy sukces zawdzięczał fenomenalnej pamięci i pomocy swojego brata Augusta. Dzięki jego pomocy ukończył szkołę i studia wyższe na Uniwersytecie w Coimbrze. Opanował między innymi w sposób doskonały język łaciński i literaturę rzymską. Poeta debiutował w 1821 roku utworem Cartas de Echo e Narciso, napisanym w stylu klasycznym, na którym się wychował. Natomiast tomy Primavera (1822) i Amor e Melancholia (1823), jakkolwiek kontynuujące typową dla oświecenia tradycję bukoliczną, zdradzają cechy romantyczne. Jednak niedługo potem autor dał się poznać publiczności jako dojrzały romantyk, wydając tomy A noite de Castello (1836) i Cuimes do bardo (1838). W 1834 Castilho ożenił się z Marią Isabel Baena Coimbra Portuga, która zmarła w 1837 roku. Epos o wstąpieniu na tron Jana VI przyniósł mu lukratywne stanowisko w Coimbrze. Podczas pobytu na Maderze ożenił się z Aną Carlotą Xavier Vidal, która urodziła mu ośmioro dzieci. Powróciwszy z Madery, założył pismo Revista Universal Lisbonense. Jako kompetentny filolog klasyczny był autorem wstępu i komentarzy do serii Livraria Classica Portugueza (1845–1847, 25 tomów). Założył też Towarzystwo Przyjaciół Literatury i Sztuki. W 1854 roku udał się w podróż do Brazylii, czego literackim świadectwem był List do cesarzowej. W 1865, po śmierci Almeidy Garretta i zamilknięciu Alexandre'a Herculana, zajmował pierwszoplanową pozycję w gronie portugalskich literatów. Stan ten jednak nie trwał długo. Wraz z pojawieniem się młodych pisarzy takich jak Antero de Quental i João de Deus jego popularność zaczęła maleć. Kiedy dziesięć lat później umierał, sława nie była już jego udziałem.

Twórczość
Antonio Feliciano de Castilho zaczynał jako autor klasycystycznej poezji sielankowej i właściwie do końca pozostał twórcą idealizującym rzeczywistość.  Zbiory A noite de Castello i Cuimes do bardo zawierają w sobie wszystkie blaski i cienie jego twórczości. Brak wyższych idei artystycznych i intelektualnych poeta pokrywał emocjonalnym wdziękiem, czystością dykcji i melodyjną wersyfikacją. Wyrósłszy z nurtu poezji opisowej i dydaktycznej, widział świat nie takim, jakim jest, ale takim, jakim powinien być. Był też zasłużonym tłumaczem, między innymi Anakreonta, Wergiliusza, Owidiusza i Moliera.

Przypisy

Linki zewnętrzne
 Fragmenty utworów Antonia Feliciana de Castilho w serwisie Projecto Vercial.

Portugalscy poeci XIX wieku
Urodzeni w 1800
Zmarli w 1875
Ludzie urodzeni w Lizbonie

redpajama_set_name: RedPajamaWikipedia


I've been keeping this simple recipe so that I can bake this with 宝贝. I can't remember where I copied it from though. I usually copy and paste interesting recipes into my phone notes.
She's been clamoring to bake cookies ever since she did it at school and at Totts. She even went shopping for baking stuff with me. We bought a couple of cool gingerbread boy and girl cookie cutters which have been idling in the drawer for months.
We needed to bring food for her school's pattern party and the same day was also Teacher's Day so I thought, why not?? We made one for everyone in class, including her 3 teachers. We even made 2 more for her "bus" friends. We even had a lot of dough leftover for our own consumption.
The butter cookies were of the right texture – not moist and with the right crumbly taste. Pretty yummy actually and neither were they overly sweet. Definitely a recipe for keeps.
I set her to the task of measuring out the ingredients. It trained her motor skills and it helped her with recognizing numbers in the hundreds. She diligently measured out the ingredients and set them aside. I only measured out the butter which was too difficult for her to cut up.
I kneaded all the ingredients into a big chunk of dough. Then it's over to her again. She took the dough out bit by bit, flattened them and cut the shapes out with cookie cutters. I helped her lay them neatly on the paper lined baking trays as they were too soft to be handled by her. See all the misshapen ones out there!
Check out the little gingerbread boys and girls, pigs, rabbits and birds.
Simple right? Just 4 ingredients. You can add crushed nuts and dried fruits to it. Or you can decorate the cookies with frosting after they are baked.
2. Add softener butter into the flour sugar mixture. Add the egg in.
3. Knead until the dough is formed.
4. Roll the dough. Flatten it. Cut out the dough with cookie cutters.
5. Bake them for 13-15 mins in a preheated oven for 180°C. If you are using an air fryer, bake the dough for 10 mins at 180°C in the baking tray. I used both because I was trying to finish the baking as soon as I could.
Easy peasy. If 宝贝 and I can bake them, anyone can!


PCR or polymerase chain reaction is a special technique that is used in molecular biology and amplifies one piece of DNA generating thousands and millions of copies of a single DNA sequence. Those who are not into microbiology may find this to be a really complicated thing, but when a PCR test is done in a laboratory you will understand how interesting it is. PCR is done in an enclosed chamber because no other atmospheric conditions should get involved during this test. You will often find patients going for PCR test for TB or PCR test for HCV or even PCR Test for cancer.
If you are wondering where the right diagnostic center for PCR HIV test in Hyderabad would be, then you should visit SL Medquest Diagnostics Center. Here, we have the most advanced equipments and a team of highly experienced doctors and technologists. Our team has worked together for a number of years and we have been fulfilling our aim of providing quality health care diagnostic needs to patients. Since the price of all the diagnostic tests are quite low compared to other centers, people often come to us. We are very renowned in Hyderabad for our laboratory services. From the day SL Medquest Diagnostics Center started, we have provided exception services to all our patients. That is why we have become the leading organization in the health care industry in the recent years. Our dedicated service to our patients has made us the best in the business.


One problem: this Gotham, as a location, is startlingly uninteresting. All logos and images are copyrighted by their respective owners. Meanwhile, Batman will also have to gain the respect and trust of James Gordon and Commissioner Loeb, whose budding relationships will prove critical to his future endeavors. The snow crushes underfoot, the bombs explode with debris that can then be kicked around, and the toilet paper banners overhead can, indeed, be hit by your Batarang. Less-notable characters from the comics were considered less compelling than more-popular characters. Well, I mean, I might as well, right? But it's fine, because I solved the puzzle, and I'm finally at the bank, and there's a cache of weapons nearby that I can destroy? Scene: Blackgate Prison Bane battle.
The premise is relatively simple. During multiplayer, Batman and Robin will be pitted against three vs. Three Joker gang members fight three Bane gang members, and in turn the team of Batman and. The Batcave is also a hub where Batman can change costumes, upgrade his equipment and access challenge maps to practice combat these maps were accessed separately in previous games. You know there's only one way to stop me. Archived from on May 13, 2014. This game — again — centers Batman as the hero for not just comic book fans, but those in search of the best visual experience available in the gaming world today.
Batman saves the Joker, leaving him with the police. The gadget that are taken fromt the previous game are Cryptographic Sequencer which is used to hack security consoles, The Batclaw which is used for hooking onto surfaces, Batarang for thorwing weapons, The Remote Batarang for remote-controlled counterpart, Explosive Gel especially for the destroy weak surfaces and knock down enemies and Grapnel Accelerator, an earlier version of the Grapnel Boost. This game is written by Corey May, Ryan Galletta and Dooma Wendschuh. With the imminent release of Batman: Arkham Origins, we take a look at some of the key gameplay and multiplayer features Batman: Arkham Origins is an upcoming prequel to the two previous, critically acclaimed, games of the franchise, Batman: Arkham Asylum and Batman: Arkham City. The Batman: Arkham Origins — Original Video Game Score was released by on October 22, 2013 and features 32 tracks composed for the game. Written by , Ryan Galletta and , the game's main storyline is set five years before that of 2009's and follows a younger, less-refined Batman.
The assassins selected for the game were chosen for abilities which would challenge the game mechanics. The Batman: Arkham Origins Wikia website states that Arkham City will not have been completely constructed yet, with Jezebel Plaza remaining a sprawling shopping center and the dock areas still in existence, prior to being devastated by the great flood. This game is successor to the 2011 video game Batman Arkham City and comes at 3rd number at series of Batman Arkham series. Experience exotic locales including a bamboo forest and mountain-top monastery. Batman's relationship with Alfred is strained; the butler, an overbearing parental figure, reminds him of his parents' deaths and Alfred sees Batman as a spoiled child squandering his inheritance on a vigilante crusade.
It was also the top-selling game on the digital-distribution platform between October 20 and 26, 2013. New to the franchise, however, is the Remote Claw. This pack contains Bruce Wayne and Vigilante skins, four challenge maps, and a challenge campaign. Archived from on May 13, 2014. Small and large crime scenes are distributed throughout. Batman chases the Joker to the Sionis Steel Mill, where he frees Black Mask and defeats the poisonous assassin Copperhead.
About five to seven years before the events of Arkham Asylum Batman is on the verge of completing his second year of crime fighting and for the most part is use to fighting those who are weaker and slower then him. The main storyline is five years before the 2009 Batman Arkham Asylum is on a younger batman. Tracking the Joker to the Gotham Royal Hotel, Batman discovers that the villain and his men have filled the hotel with explosives, murdered the staff, and taken the guests hostage. Archived from on May 13, 2014. The villains, including the and , take advantage of the chaos to launch nefarious schemes, while Gotham City police try to apprehend Batman. Using the database, Batman deduces that Black Mask was kidnapped by the Joker, presumably to access the Gotham Merchants Bank. See also: and Arkham Origins is an incorporating tactics.
Archived from on July 23, 2014. To help you navigate, in this guide, there have also been included detailed maps of Arkham, and the other main locations. The Single player campaign may still be played and enjoyed offline. Take control of Deathstroke - the world's deadliest assassin - when you download the Deathstroke Challenge Pack. Return to Gotham City to ring in the New Year, Arkham Origins style.
Partially, the problem here is Batman's comically as in funny, not comic book-inspired hefty utility belt full of tools. Using an enhanced version of the series' Freeflow combat system, combat introduces a tracking system assessing the players' efficiency and highlighting battle achievements such as avoiding damage and using gadgets. Black Mask has a bounty on Batman, which attracts eight accomplished assassins: the physically imposing Bane ; expert marksman ; veteran mercenary ; poisonous contortionist ; the pyromaniac ; the highly charged ; deformed criminal , and master martial artist. Coinciding with Arkham Origins ' United Kingdom launch, voice actors Roger Craig Smith and Troy Baker made a public appearance at 's retailer. In February 2013, it was reported that a new game in the Batman Arkham franchise would be released by a developer other than Rocksteady. GameSpot noted that poor weapon accuracy and movement controls made the thugs seem weak and inept, while playing as the heroes lacked empowerment because of more restrictive combat ability and less resistance to damage. Scene: Blackgate Prison Bane battle.
The entire guide has been supplemented with a list of the achievements available in the game. In July, it was announced that Arkham Origins would be the first game in the Arkham series to feature multiplayer gameplay. Meanwhile, fans of the franchise will recognize some familiar areas, including Old Gotham, Park Row and Bowery. Fighting the things you find? The assassins leave, except for Bane, who thinks Batman is coming for the Joker. It also can disable some enemies and stun shielded ones, and short-circuit objects, and the Concussion Detonator, capable of stunning large enemy groups.


Hwy 95 Bayport and Lakeland project location map.
In spring 2020, a five mile section of Hwy 95 between Bayport and Lakeland in Washington County will undergo a road improvement project. The work will include pavement, drainage, bike and pedestrian improvements. Check out the Visualization section for proposed views for 1st and 3rd Avenues.
Specific details for traffic impacts will be provided as they become available.
Note: Local Access will be maintained during the duration of the project.
MnDOT has a proposed view for Hwy 95 at 1st and 3rd Avenues.
Proposed view: Hwy 95 at 1st Ave.
Proposed view: Hwy 95 at 3rd Ave.