இது உலக நாடுகளின் ஒரு அகரமுதற் பட்டியலாகும். நீங்கள் நாடுகளை தலைநகரம்வாரியாகவோ, கண்டங்கள் வாரியாகவோ, மக்கள்தொகை வாரியாகவோ, பரப்பளவு வாரியாகவோ, மக்கள்தொகை அடர்த்தி வாரியாகவோ, நேர வலயம் வாரியாகவோ கூட உலவலாம்.

விக்கித் திட்டம் நாடுகள் திட்டமானது தமிழ் விக்கியில் காணப்படும் மற்றும் இனி வரவிருக்கும் நாடுகள் பற்றிய கட்டுரைகள் ஒரு சீர்தரத்துக்குள் கொண்டுவரும் நோக்கில் அமைந்தது.

மேலதிக மூலங்களுக்கு புவியியல் குறிப்புகளைப் பார்க்கவும்.
{| id="toc" border="0"
! :
அ ஆ இ ஈ உ ஊ எ ஏ ஐ ஒ ஓ க ச ட த ந ப ம ய ர ல வ ஹ ஸ ஜ
|}
<table border=1 cellpadding=1 cellspacing=0 style="float: right; border-collapse: collapse;">
நாடுவாரியான பட்டியல்

அ 
 
  (ஐக்கிய அமெரிக்க நாடுகள்)
 
 
 
 
 
 
 

 ஆ 
 
 
 
 
 

 இ 
 
 
 
 
 
 

 ஈ 
  
 

 உ 
  
  
  
 
  
 ஊ 

எ
 
 
 
 
 
 
 

 ஏ 

ஐ
 
 
 
 

 ஒ 
 ஒல்லாந்து நெதர்லாந்து பார்க்கவும்.

 ஓ 
 

 க 
 
 
 
 
 
 
  (முன்னர் ஸயர்) 
 
 
 
 
 
 
 
 
 
 
 2 
 
 
 
 
  
 
 
 
 
 

 ச 
 
 
 
 
 
 
 
 
 
 
 
 
 1 (தாய்வான்) 
  
 
 
 
  
 
 
 
 
 
 
 
 
 
 

 ட 
 ட்ரினிடாட்டும் டொபாகோவும் 
  
 டொங்கா 
 டொமினிக்கா 
 டொமினிகன் குடியரசு 
 டோகோ

 த 
  
 தாய்வான் (பார் சீனக் குடியரசு1) 
 தான்ஸானியா 
 தாஜிக்ஸ்தான் 
 திமோர் லெஸ்தே (பார் கிழக்குத் திமோர்) 
  
 துருக்மெனிஸ்தான் 
 துவாலு 
 துனீசியா 
 தென் கொரியா 
 தென்னாபிரிக்கா

 ந 
  
  
  
  
  
  
   
  
  2 
 

 ப 
  
 பர்மா (இப்பொழுது மியன்மார்) 
  
  
  (பார் மேற்குக் கரை)
  3 
 
 
 
  
 
  
  
  
  
  
 
  
  
  
 
  
  
 
 
 
  
  
  
   
  
 

 ம 
  
 6
 
  
  
  
  
  
  
  
  
 மேற்கு சமோவா(இப்பொழுது சமோவா)
 5 
 
 
  
  
 
  
  
 
 

 ய 
 யேமன்
 யப்பான்

 ர 
 ரஷ்யா 
 ருமேனியா 
 ருவாண்டா

 ல 
  
  
  
  
  
 லெய்செஸ்டீன்(Liechtenstein) 
  
  
 

 வ 
  
  
  4 (Holy See) 
  
  
 

 ஹ 
 ஹங்கேரி
 ஹைத்தி 
 ஹொண்டூராஸ்

 ஸ 
 ஸ்பெயின் 
 சிலவாக்கியா
 சிலவேனியா
 சாம்பியா
 ஸயர் (இப்பொழுது கொங்கோ ஜனநாயகக் குடியரசு) 
 ஸிம்பாப்வே

 ஜ 
 ஜமேக்கா 
 ஜிபூட்டி
 ஜெர்மனி 
 ஜோர்தான்
 ஜோர்ஜியா

குறிப்புகள் 
இங்கு பட்டியலிடப்பட்டுள்ள நாடுகளின் நிலைமை / இறைமை பற்றிய விபரங்கள்.

 1 சீனக் குடியரசு(தாய்வான்): Political status of Taiwan பார்க்கவும்.
 2 குக் தீவுகளும் நியூவும்: நியூசிலாந்துடனான ஒரு free கூட்டு (association); Niue Constitution Act 1974 (NZ) ஐயும் பார்க்கவும்.
 3 பலஸ்தீனம்: "பலத்தீன் நாடு" 1988 ஆம் ஆண்டு பிரகடனப்படுத்தப்பட்டுப் பல அரபு மற்றும் முஸ்லிம் நாடுகளால் அங்கீகரிக்கப்பட்டுள்ளது. proposals for a Palestinian state ஐயும் Palestinian territories ஐயும் பார்க்கவும். காஸா Strip, மேற்குக் கரை, இஸ்ரேல் என்பவற்றுக்குப்பலஸ்தீனப் பிரதேசம் தொடர்பில் கட்டுரைகள் உள்ளன.
 4 வத்திக்கான்: Holy See பார்க்கவும்.
 5 மேற்கு சஹாரா: Politics of Western Sahara பார்க்கவும்.
 6 மசிடோனியக் குடியரசு: "முன்னாள் யூகோஸ்லாவியாவின் மசிடோனியக் குடியரசாக" அனைத்துலக அளவில் பரிச்சயமானது. **http://www.un.org/documents/ga/res/47/a47r225.htm ஐப் பார்க்கவும்.

தொடர்புள்ள தலைப்புகள் 
 ஐ.எசு.ஓ 3166-1
 இறைமையுள்ள நாடு
 உலக நாடுகள் பட்டியல் (கண்டங்கள் வாரியாக)
 பன்னாட்டுத் தலைநகரங்களின் பட்டியல்
 உலக நாடுகளின் மரபுச் சின்னங்கள்
 ஏற்கப்படாத நாடுகள்
 சார்பு மண்டலம்

 
நாடுகள் தொடர்பான பட்டியல்கள்

nds:Land#Länner
sv:Världsgeografi#Lista över länder

Maria, a Judia ou Maria, a Profetisa, é uma antiga filósofa grega e famosa alquimista que viveu no Egipto por volta do ano 273 a.C..

Alguns a situam na época de Aristóteles (384–322 a.C.), uma vez que a concepção aristotélica dos quatro elementos formadores do mundo (o fogo, o ar, a terra e a água) condiz bastante com as idéias alquimistas de Maria, como o axioma de Maria: «o Um torna-se Dois, o Dois torna-se Três, e do terceiro nasce o Um como Quatro». Segundo Aristóteles, o enxofre era considerado a expressão do elemento fogo, e Maria o tomou como base para os principais processos que estudou. Ela menciona o enxofre em frases sempre misteriosas, como «uma pedra que não é pedra» e «tão comum que ninguém a consegue identificar». Maria conta que Deus lhe revelou uma maneira de calcinar cobre com enxofre para produzir ouro. Esse enxofre era obtido do disulfeto de arsênico, que é achado em minas de ouro. Talvez tenha sido essa a origem da lenda da transformação de metais menos nobres em ouro.

Dentre as invenções de Maria estão o kerotakis, uma espécie de barril fechado e o banho de vapor: para um aquecimento lento e gradual dos experimentos, em vez de manipular as substâncias diretamente no fogo, ela descobriu que era possível controlar melhor a temperatura se fosse por meio da água - que até hoje chamamos de banho-maria. Para além disso dois equipamentos de destilação (alambique), com duas ou três saídas para destilados — o dibikos e o tribikos — e um aparelho para sublimação, sendo-lhe ainda atribuída a descoberta do ácido clorídrico. A maior parte das suas escrituras foram conservadas por Zósimo de Panópolis (300 d.C.).

Fontes
Não existem elementos concretos sobre o tempo e lugar de sua vida. Ela é mencionada pelos primeiros alquimistas da história, sempre como uma autoridade e respeito extremo. Os alquimistas do passado acreditava que ela era Miriã, irmã de Moisés e Arão, o profeta, mas há evidências que apoiam que esta reivindicação é falsa.

A menção mais concreta de Maria, a Judia no contexto da alquimia é por Zósimo de Panópolis, que escreveu no século IV os livros alquimistas mais antigos conhecidos . Zósimo descreve vários de seus experimentos e instrumentos. Em seus escritos, Maria é quase sempre citada como tendo vivido no passado e citou-a como uma das "sábias".

Jorge Sincelo, um cronista bizantino do século VIII, apresenta Maria como uma professora de Demócrito, a quem ela conheceu em Mênfis, Egito na época de Péricles. No século X Kitab al-Fihrist de Ibn al-Nadim cita-a como uma das cinqüenta e duas mais famosas alquimistas, sabendo da preparação do caput mortuum. O filósofo romano Morieno chamou de "Maria, a profetisa" e os árabes a conheciam como a "Filha de Platão", um nome que em ocidentais textos alquímicos foi reservada para o enxofre branco.
No livro de Alexandre (2 ª parte) do poeta persa Nizami, Maria, uma princesa síria, visita o Tribunal de Alexandre, o Grande, e aprende a partir de Aristóteles (384 aC - 322 aC), entre outras coisas, a arte de fazer ouro.

Trabalhos

Escrituras

Sabe-se que Maria escreveu vários textos sobre alquimia. Embora nenhum de seus escritos ter sobrevivido em sua forma original, os seus ensinamentos foram amplamente citados por autores posteriores herméticos. Seu trabalho principal sobrevivente é um extrato feito por um anônimo filósofo cristão, chamado O Diálogo de Maria e Aros sobre o Magistério de Hermes, em que são descritas e nomeadas operações que seriam mais tarde a base da Alquimia, leucose (branqueamento) e xanthosis (amarelecimento). Uma foi feita por moagem e do outro por calcinação. Este trabalho descreve pela primeira vez um sal de ácido e outros ácidos que podem ser identificados com ácido acético. Há também várias receitas para fazer ouro, até mesmo de vegetais de raiz como o Mandragora.
Vários enigmáticos preceitos alquímicos têm sido atribuídas a Maria. Ela supostamente disse da união dos opostos:

Esta outra vem do Axiom de Maria

Invenções
Maria era uma trabalhadora respeitada, que inventou aparelhos complicados de laboratório para a destilação e sublimação de materiais químicos. Maria disse ter descoberto o ácido clorídrico, embora isso não seja aceito pela maioria dos textos científicos  .
Também são atribuídas a ela a invenção dos aparelhos de alquimia conhecidos como tribikos, kerotakis e o banho-maria.

Tribikos
Maria aperfeiçoou a câmara de destilação de três braços. O tribikos era uma espécie de alambique com três braços que foi utilizado para obter as substâncias purificadas por destilação. Ninguém sabe ao certo se Maria, a Judia foi sua inventora, mas Zósimo credita que a primeira descrição deste instrumento para ela. Em seus escritos (citado por Zósimo), ela recomenda que o cobre ou bronze utilizados para criar os tubos sejam da espessura de uma frigideira, e a junção entre estes tubos deve ainda ser selada com farinha de colar na cabeça

Kerotakis
O kerotakis é a invenção mais importante de Maria, a Judia, um dispositivo usado para aquecer substâncias utilizadas na alquimia e recolher os vapores. É um recipiente hermético com uma folha de cobre suspensa no topo. Quando funciona corretamente, todas as articulações são no vácuo apertado. O uso de tais recipientes fechados nas artes herméticas levaram ao termo "hermeticamente fechada". Maria e seus colegas acreditavam que a reação que se dá no kerotakis era uma reconstituição do processo de formação do ouro que acontecia nas entranhas da terra. Mais tarde, este instrumento foi modificado pelo alemão Franz von Soxhlet em 1879 para criar o extrator que leva seu nome, Soxhlet.

Banho-maria

Ver também 
 Mulheres na ciência
 Alquimia
 Judaísmo
 Moisés
 Miriã
 Banho-maria

Bibliografía 
 GREENBERG, Arthur, Chemical History Tour, Picturing Chemistry from Alchemy to Modern Molecular Science. Wiley-Interscience 2000, ISBN 0-471-35408-2
 STROHMEIER, Renate, Lexikon der Naturwissenschaftlerinnen und naturkundigen Frauen Europas. Von der Antike bis zum 20. Jahrhundert. Verlag Harri Deutsch, 1998, ISBN 3-8171-1567-9

Ligações externas

Inventoras
Alquimistas
Inventores
Filósofos da Grécia Antiga
Mulheres da Grécia Antiga
Filósofas
Mulheres na ciência
Gregos do século III a.C.
Mulheres do século III a.C.
!Mais Teoria da História na Wiki (Mulheres)
!Mais Teoria da História na Wiki (Wikiconcurso de edição)

'use strict';

const _ = require('lodash');
const fs = require('fs-extra');
const glob = require('glob');
const path = require('path');

const minify = require('../common/minify.js');

/*----------------------------------------------------------------------------*/

/**
 * Creates a [fs.copy](https://github.com/jprichardson/node-fs-extra#copy)
 * function with `srcPath` and `destPath` partially applied.
 *
 * @memberOf file
 * @param {string} srcPath The path of the file to copy.
 * @param {string} destPath The path to copy the file to.
 * @returns {Function} Returns the partially applied function.
 */
function copy(srcPath, destPath) {
  return _.partial(fs.copy, srcPath, destPath);
}

/**
 * Creates an object of base name and compiled template pairs that match `pattern`.
 *
 * @memberOf file
 * @param {string} pattern The glob pattern to be match.
 * @returns {Object} Returns the object of compiled templates.
 */
function globTemplate(pattern) {
  return _.transform(glob.sync(pattern), (result, filePath) => {
    const key = path.basename(filePath, path.extname(filePath));
    result[key] = _.template(fs.readFileSync(filePath, 'utf8'));
  }, {});
}

/**
 * Creates a `minify` function with `srcPath` and `destPath` partially applied.
 *
 * @memberOf file
 * @param {string} srcPath The path of the file to minify.
 * @param {string} destPath The path to write the file to.
 * @returns {Function} Returns the partially applied function.
 */
function min(srcPath, destPath) {
  return _.partial(minify, srcPath, destPath);
}

/**
 * Creates a [fs.writeFile](https://nodejs.org/api/fs.html#fs_fs_writefile_file_data_options_callback)
 * function with `filePath` and `data` partially applied.
 *
 * @memberOf file
 * @param {string} destPath The path to write the file to.
 * @param {string} data The data to write to the file.
 * @returns {Function} Returns the partially applied function.
 */
function write(destPath, data) {
  return _.partial(fs.writeFile, destPath, data);
}

/*----------------------------------------------------------------------------*/

module.exports = {
  copy,
  globTemplate,
  min,
  write
};

Berthold Konrad Hermann Albert Speer (Mannheim, 19 maart 1905 – Londen, 1 september 1981) was een Duits architect en stedenbouwkundige. Tijdens de naziheerschappij over Duitsland (1933-1945) was hij vanaf 1937 rijksarchitect en vanaf 1942 rijksminister van Bewapening en Munitie. Door zijn vriendschap met Adolf Hitler en zijn ministerschap gold hij als een van de machtigste mannen van het Derde Rijk. Na de oorlog werd Speer in Neurenberg veroordeeld tot twintig jaar gevangenisstraf.

Voor 1933 
Het gezin waarin Speer werd geboren, was wat ze in het Duits noemen grossbürgerlich; in Nederlandse termen gegoede burgerij of bourgeoisie. Zijn vader en grootvader waren beiden architecten. Om financiële redenen studeerde Speer aanvankelijk in Karlsruhe. Van de lente van 1924 tot de zomer van 1925 zette hij zijn studie vervolgens voort aan de technische hogeschool van München. In de herfst van 1925 verhuisde hij naar Berlijn en probeerde hij vergeefs aan de Technische Hogeschool in Berlijn-Charlottenburg in het seminarie van Hans Poelzig toegelaten te worden. In 1926 ontving Heinrich Tessenow, een architect van de behoudende school met een zeer bescheiden en niet megalomane stijl, een leerstoel. Speer werd in dat jaar een van zijn studenten. Na zijn diploma te hebben behaald in 1927 bleef Speer nog meerdere jaren, als Tessenows assistent, aan de hogeschool verbonden.

Architect in dienst van Hitler 

Speer was niet bijzonder geïnteresseerd in politiek. Hij werd echter reeds in januari 1931 lid van de NSDAP nadat hij in december 1930 een toespraak van Adolf Hitler had bijgewoond in de Berlijnse Hasenheide. Deze toespraak had een diepe indruk gemaakt op Speer. Zelf schreef hij dat hij een maand had getwijfeld, maar dat hij uiteindelijk toch besloten had om lid te worden, omdat Hitler helemaal niet stereotiep was overgekomen in de toespraak. Het was een zeer rustige toespraak waarin het woord 'Jood' niet één keer was gevallen.

In 1932 verliet Speer Berlijn en ging terug naar Mannheim. Hij vestigde zich daar als architect, maar hij kreeg geen opdrachten. In 1934 werd hem gevraagd de meivieringen van de partij vorm te geven. Speers originele idee was om rond het veld in Neurenberg waar de parades werden afgenomen een reeks zoeklichten recht omhoog te laten schijnen. Hierdoor ontstond een mooi lichtspel wat een koepel van licht boven het paradeveld veroorzaakte. Hitler was hierover zeer enthousiast en zo werd Speer Hitlers huisarchitect.

Toen Hitlers toenmalige Hofarchitekt, de uit München afkomstige Paul Ludwig Troost, in 1934 overleed, nam Speer diens taken over, waarmee hij zijn formele leidinggevende Rudolf Hess feitelijk snel overschaduwde in macht en ook in aanzien bij Hitler. Speer ontwierp talrijke gebouwen in klassieke stijl, die als doel hadden de pracht en de macht van het Derde Rijk te tonen en te onderstrepen. In het Deutsche Arbeitsfront (DAF) leidde hij de afdeling Schönheit der Arbeit. Verder werd hij de chef van de onderafdeling van de Rijkspropagandaleiding en verantwoordelijk voor de stedenbouw in de staf van Rudolf Hess.

Voor de wereldtentoonstelling van 1937 in Parijs ontwierp hij het Duitse paviljoen. Het hoofdbestanddeel bestond uit een enorme toren in classicistische stijl met een grote Duitse adelaar erop. Speer kreeg er de Grand Prix met een gouden medaille voor.

De belangrijkste gebouwen en de aanleg van urbane ruimtes voor het Derde Rijk ontwierp Speer echter in Berlijn en Nürnberg. Berlijn als rijkshoofdstad en bestuurscentrum lag voor de hand. In Nürnberg werden voor de machtsovername al diverse zogenaamde partijdagen gehouden, propagandistische massabijeenkomsten georganiseerd door de NSDAP, om het nationaalsocialisme te etaleren aan de Duitse kiezers. Deze Beierse stad lag niet ver van München, de bakermat van de nazipartij, en was daarbij goed bereikbaar via een uitgebreid verkeersnetwerk en bezat als toeristische trekpleister voldoende hotels om veel volk onderdak te bieden. Nürnberg kozen de nazi's ook meer symbolisch als zijnde een belangrijke vroegere rijksstad van het Heilige Roomse Rijk, de plek waar men destijds de rituele symbolen van de keizerlijke macht bewaarde zoals de rijksappel, de scepter en de kroon. De nazi's zetten met de keuze van Nürnberg een eeuwenoude traditie van jaarmarkten, machtige keizers en kastelen voort door daar de nazipartijdagen te laten plaatsvinden. Na de verkiezingsoverwinning in 1933 ging het terrein van de partijdagen grondig op de schop en werd in opdracht van Hitler flink uitgebreid.

Berlijn

In 1937 werd hij benoemd tot regeringscommissaris voor de bouw in de staf van de Führer en inspecteur-generaal voor de bouwnijverheid in Berlijn. Zijn ontwerpen waren naar de smaak van Hitler die hield van gebouwen in een neoclassicistische stijl met een minimalistische uitstraling maar dan vergroot tot buitensporige afmetingen. Voor de spaarzame aankleding wilde Hitler het liefst de klassieke Arische beelden gebruiken van de hand van de door Hitler bewonderde Arno Breker. Vooral voor Berlijn had Hitler grootse plannen. Deze stad zou na de Endsieg herdoopt worden in Germania (overigens is Speer de enige bron die dit beweerde). Met talloze statige bouwwerken en brede boulevards wilde Hitler aan zijn hoofdstad een enorme grandeur geven. Hitlers en Speers megalomane motto was: 'hoe groter hoe beter'. Speer ordonneerde stabiliteitstesten in de moerassige grond van Berlijn om na te gaan of deze het enorme gewicht van de geplande gebouwen kon dragen. Daartoe bouwde de firma Dyckerhoff & Widmann AG in 1941 tegen de prijs van 400 000 Reichsmark aan de rand van Berlijn het Schwerbelastungskörper. Het betrof een betonnen 12 360 ton wegende cilinder met een diameter van 21 m. De nog intact zijnde kolos veroorzaakte volgens Speers metingen een verzakking van 19 cm. De Berlijnse ondergrond was bijgevolg geschikt voor het bouwen van dergelijke grootschalige bouwwerken. Tevens werd een begin gemaakt met het aanleggen van de weids opgezette boulevards. In 1938 en 1939 werd in recordtijd de bouw van de nieuwe Rijkskanselarij aan de Wilhelmstrasse en de Voßstraße voltooid. Speer toonde zich hier al als een goede bouworganisator. Het bouwwerk met gigantische afmetingen (het geheel mat 200 ha) was voor Hitler een representatieve plaats om de buitenlandse gasten en diplomaten te ontvangen. Zij moesten op deze wijze onder de indruk raken van de grootsheid van het Duitse Rijk. Het merkwaardigste onderdeel van het geheel betrof een lange rechte galerij van 146 m lengte, twee maal zo lang als de spiegelzaal in Versailles van 73 meter, met een spiegelgladde vloer die leidde naar de persoonlijke ontvangstruimten van Hitler; deze "straat" werd "der lange Marsch der Diplomaten" genoemd. Sommigen maakten de opmerking dat de gladde vloer eigenlijk wel gevaarlijk was om op te lopen. Hitler wimpelde deze bezwaren weg met de woorden: “Diplomaten zijn wel gewend om zich op glad ijs te begeven”. Door het uitbreken van de oorlog moesten verdere plannen echter opgeschort worden. Gereed kwamen wel het vliegveld Tempelhof dat nog steeds een van de grootste luchthavengebouwen ter wereld heeft. Ook het nog steeds gebruikte Olympisch Stadion van 1936 was een onderdeel van de herbouw van Berlijn. Hitlers nieuwe kanselarij werd tijdens de eindstrijd in 1945 zwaar beschadigd en kort na de oorlog afgebroken.

Nürnberg

In deze vroegere Rijksstad, in het Nederlands wordt de stad meestal Neurenberg genoemd, ontwierp Speer vanaf 1934 een aantal gebouwen op het Reichsparteitagsgelände (de terreinen van de rijkspartijdagen) vertrekkende van het masterplan van architect-urbanist Paul Ludwig Troost. Troost kreeg van de partij opdracht om een recreatiegebied aan de stadsrand om te vormen tot een geschikte locatie voor een massa-evenement het zogenoemde Reichtsparteigelände, een gebied van 11 km². Men verplaatste daartoe de dierentuin en de vuurtoren brak men af. Men voorzag in een Große Straße van 1,5 km lengte en 50 m breed die visueel aansloot op de middeleeuwse keizerlijke burcht van Nürnberg. Gevangenen van het concentratiekamp Flossenbürg en Mauthausen kapten het graniet voor de 6 000 tegels waarover de soldaten zouden marcheren. Langs deze lange straatas plande men de Luitpoldarena, het Zeppelinveld, het Deutsches Stadion, een Hitlerjugendstadion, een Marsveld en twee treinstations. Slechts het Zeppelinveld met dito tribune naar een ontwerp van Speer werd afgewerkt. De kosten van de oorlogsindustrie beletten de verdere uitbouw van al deze megalomane plannen. Voor de tribune met een lengte van 360 m stond het antieke kleinschaligere Pergamonaltaar model. 320 000 toeschouwers konden de parades op het Zeppelinfeld volgen. Bij nacht schenen 250 grote spots de lucht in als een van ver te ziene lichtkathedraal. Nu is de plek herschapen tot een ruïne en op eigen risico te betreden. Via Google Earth kan men inzoomen op het Zeppelinveld en krijgt men een beeld van de huidige vervallen toestand.

Op deze plek filmde Leni Riefenstahl Hitlers propagandafilm Triumph des Willens over de aldaar gehouden Rijkspartijdag van 5 september 1934. Neurenberg is ook bekend van de Rassenwetten van Neurenberg en het ontnemen van burgerrechten van Joden. In deze stad vonden ook de naoorlogse processen van Neurenberg plaats. Door misleiding van het tribunaal wist Speer aan de doodstraf te ontkomen.

Speer als organisator en minister van bewapening vanaf 1942

Toen Hitler later meer en meer door de oorlog werd opgeslokt, verminderde zijn aandacht voor Speer maar hij verloor Speer omwille van zijn goede managerskwaliteiten niet echt uit het oog. Op 8 februari 1942 werd Speer, ondanks (of misschien wel dankzij) zijn vrij geringe politieke aspiraties, door Hitler benoemd als opvolger van de bij een vliegtuigongeluk omgekomen rijksminister voor Bewapening en Munitie, Fritz Todt. Speer gebruikte al zijn organisatietalent, reorganiseerde de productie van wapens en munitie.

Het Endspiel

Hitlers laatste bevelen aan Speer 
In de laatste weken van de oorlog weigerde hij Hitlers bizarre bevelen nog langer uit te voeren. Hitler wist dat de oorlog verloren was en wilde het Duitse volk, dat in zijn ogen in zijn missie gefaald had, met hem mee de afgrond in sleuren in een soort Götterdämmerung met het Nero-bevel. Dit moest bereikt worden door het vernietigen van de nog overgebleven, vitale delen van Duitsland en de bezette gebieden: de tactiek van de verschroeide aarde. Speer dacht al aan het overleven van de bevolking en de wederopbouw van Duitsland na de oorlog en gaf Hitlers bevelen niet meer door aan de afdeling die voor de uitvoering moest zorgen. Een eerder voorbeeld was Hitlers bevel in 1944 om Parijs te vernietigen toen de geallieerden de stad naderden. Doordat de Duitse commandant van Parijs (luitenant-generaal Dietrich von Choltitz) hier niet aan meewerkte en ook door de zeer snelle omsingeling en verovering van Parijs werd dit verhinderd.

Arrestatie 

Op 24 april 1945 vloog Speer, die Berlijn al was ontvlucht, speciaal terug om in de bunker onder de Rijkskanselarij afscheid van zijn Führer te kunnen nemen. Hitler pleegde uiteindelijk op 30 april zelfmoord, samen met Eva Braun die even tevoren met hem getrouwd was, en liet zijn instortende "Derde Rijk" in totale chaos achter. Op 23 mei 1945 werd Speer samen met Karl Dönitz (door Hitler per testament aangewezen als zijn opvolger) gearresteerd in Flensburg, van waaruit verschillende nazileiders, die niet in Berlijn waren gebleven, tevergeefs vredesonderhandelingen met de geallieerden trachtten te voeren.

Proces van Neurenberg en gevangenschap 
Op 1 oktober 1946 werd Speer op het Proces van Neurenberg veroordeeld tot twintig jaar gevangenisstraf, vooral vanwege het feit dat onder zijn leiding één miljoen van de in totaal zes miljoen dwangarbeiders uit de bezette gebieden tijdens de oorlogsjaren in de wapenindustrie te werk waren gesteld. Van alle veroordeelde nazikopstukken was hij de enige die zich "verantwoordelijk" verklaarde voor de misdrijven van de nazistaat. Desondanks pleitte hij niet schuldig met als argument dat hij nooit persoonlijk opdrachten ondertekend had om gevangenen te deporteren. Speer schoof zijn volledige schuld af op de Minister van Arbeid, Fritz Sauckel die wel werd opgehangen. Zijn straf zat hij grotendeels uit in de Spandaugevangenis in Berlijn. Op 1 oktober 1966 kwam hij vrij.

Speer als de “nette nazi” 
Speer heeft tijdens het proces in Neurenberg als enige top-nazi bekend medeverantwoordelijk te zijn aan de misdaden die tijdens het Derde Rijk zijn begaan. Dit medeschuldig zijn werd door hemzelf echter weer snel gebagatelliseerd: hij schilderde zichzelf af als iemand die verblind was door Hitlers megalomane dromen. Vooral de mogelijkheid om zijn gigantische architectonische ontwerpen, met behulp van Hitlers steun, onbegrensd te kunnen verwezenlijken had Speer, naïef als hij toen volgens zichzelf was, over de streep getrokken. Met deze zienswijze suggereerde Speer dat zijn medewerking aan het regime toch enigszins buiten zijn schuld om was gebeurd: hij wist niet beter. Van de gruwelijke toestanden in de vernietigingskampen en de Jodenvervolging had Speer (naar eigen zeggen) sowieso keine Ahnung (geen weet).

Verder schreef hij, om zich te verdedigen tijdens het Neurenberg-proces, nog enkele "goede" maatregelen op zijn naam; zo verklaarde hij bij het zien van de slaapplaatsen van de dwangarbeiders in de steenhouwerijen en fabrieken van V2-raketten voor betere verblijfplaatsen te hebben gezorgd.

Na 'Spandau' en Speers overlijden 
Speer woonde na zijn vrijlating in de villa in Heidelberg die zijn vader in 1905 had laten bouwen. Hij trad daarna niet echt meer in de openbaarheid, op een enkel interview na, en besteedde zijn tijd aan het uitwerken van zijn aantekeningen en het publiceren ervan in verscheidene boeken. Door de inkomsten van zijn boeken en, zoals later bleek, ook door de heimelijke verkoop van tijdens de oorlog geroofde schilderijen kon Speer tot zijn dood een welgesteld leven leiden. In 1981, tijdens een bezoek aan Londen, overleed Speer vrij onverwacht aan een herseninfarct.

Nalatenschap en het einde van de mythe 
Speer liet tekeningen en een hoeveelheid dagboekaantekeningen na, die uit de gevangenis waren gesmokkeld. Deze werden in 1969 in boekvorm uitgegeven onder de titel Spandauer Tagebücher (later vertaald in het Engels onder de titel Spandau – the secret diaries). Zijn levensverhaal vertelt hij in Erinnerungen (Herinneringen). Ook over de rol van de SS schreef hij een boek: Der Sklavenstaat: Meine Auseinandersetzungen mit der SS. Tot slot is ook het boek Technik und Macht min of meer van zijn hand, namelijk Speers woorden, vastgelegd door Adelbert Reif.

Niet lang voor Speers onverwachte dood kwamen Duitse onderzoekers op het spoor van Speers werkelijke verantwoordelijkheid voor oorlogsmisdrijven. Speers vroegere medewerker Wolters was een fanatiek nazi gebleven en was zo verontwaardigd over Speers "verraad" van Hitler dat hij op zijn beurt onthullingen deed over Speer. Zo was het Speer die regelde dat tijdens de voorbereidingen voor de aanleg van de brede boulevards in Berlijn de Duitse bewoners van 23 765 onteigende woningen de woningen van Joden kregen toegewezen.<ref> Joseph Pearce, De doodsteek voor de 'goede nazi''', in: De Morgen, 26 september 2018. </ref> De Joodse bewoners werden op transport gezet naar de concentratiekampen. Albert Speer heeft zijn ontmaskering niet meer meegemaakt.

Onderzoek dat na de dood van Speer door Matthias Schmidt werd gepubliceerd, toonde aan dat Speer een zorgvuldig web van misleiding rond zijn werkelijke aandeel in de oorlogsmisdaden had geweven. Nauwkeurig historisch onderzoek van de Duitse historicus Magnus Brechtken ontkracht systematisch de door Speer geschapen mythe van Hitlers onwetende architect. Speer stelde onder meer niet aanwezig te zijn geweest bij de beruchte rede in Posen waarin Heinrich Himmler de nazileiders betrok bij de massamoord op de Joden. Himmler sprak op de geluidsopname daarentegen rechtstreeks tot Speer, dat wil zeggen, alsof Speer aanwezig was. Ook een document waarop materiaal voor de bouw van crematieovens en lijkenkelders in een concentratiekamp werd vrijgegeven met Speers handtekening van goedkeuring erop was voor Speer zeer belastend. In overleg met SS leider Heinrich Himmler besprak en leidde Speer als Generalbauinspektor de uitbreiding van het concentratiekamp Auschwitz. De kampen Sachsenhausen en Mauthausen ontstonden op aansturen van Speer om slavenarbeiders te leveren voor de ontginning van graniet, nodig voor Speers monumentale nazibouwwerken.

Speer heeft zijn medeplichtige Rudolf Wolters na de oorlog opdracht gegeven om belastende documenten te vernietigen. In de memoires liegt Speer over zijn bezigheden vlak voor de val van het Derde Rijk. Speer heeft een kostbare collectie romantische schilderijen, gestolen of afgeperst uit Joods bezit, verborgen. Na zijn vrijlating heeft hij de schilderijen voorzichtig en anoniem verkocht. De contant uitbetaalde opbrengst werd weggesluisd, waarschijnlijk naar zijn jonge maîtresse. De kunstwerken brachten een miljoen mark op. De opbrengst van de speculatie met een van de Joodse bankierserfgename Marie-Anne von Goldschmidt-Rothschild afgeperst stuk kostbare bouwgrond aan de oever van Schwanenwerder bij Berlijn moest Speer restitueren. Dat heeft hij ondanks een veroordeling nooit gedaan.

Gesprekken met Gitta Sereny leidden tot een boek van haar hand. Ze portretteerde Speer als een man die niet met zichzelf in het reine kon komen.

 Perspectief voor Speers architectuur 

Speer bedacht het Ruinenwert-principe. Dit hield in dat de ontwerper een gebouw zo moest vormgeven dat het ook als ruïne mooi zou ogen. De aftakeling van Speers gebouwen startte vlugger dan voorzien. De tribune van het Zeppelinveld van het Reichsparteigelände in Nürnberg brokkelde af vanaf de jaren zestig van de twintigste eeuw. Het stadsbestuur moest daartoe in 1967 een deel van de bouwvallige zuilengalerij afbreken. De tienduizenden toeristen die de gebouwen jaarlijks bezoeken maken nu hun selfies op eigen risico.Het grootschalige karakter van Speers bouwwerken en de prominente aanwezigheid ervan vooral in Nürnberg, plaatsen de Duitsers voor een dilemma hoe om te gaan met dit beladen erfgoed dat voortdurend herinnert aan de naziperiode. Het Neurenbergse stadsbestuur is vastberaden (2016) om het patrimonium ondanks de oplopende kosten in stand te houden en in te richten als plek van educatie en herinnering. Daartoe bouwde men in 2001 al een Dokumentationszentrum Reichsparteitagsgelände aan de noordelijk gelegen kop van het congrescentrum dat in 1935 gebouwd werd door architect Ludwig Ruff op het terrein. Aldaar ingerichte tentoonstellingen geven een beeld van de Ursachen, Zusammenhängen und Folgen der nationalsozialistischen Gewaltherrschaft. Besluit 
Nauwkeurig en uitvoerig bronnenonderzoek leidt tot de conclusie dat Speer tijdens het twaalf jaar (1933-1945) durend nazi-bewind twee doelen nastreefde: de nationaalsocialistische leer helpen uitvoeren en zichzelf verrijken. Tijdens de Neurenbergse processen en nadien stelde Speer alles in het werk om dit te verdoezelen en zichzelf neer te zetten als een "nette onwetende technocraat" die slechts voor het regime burgerlijke bouwwerken bedacht en uitvoerde. Daarbij kreeg hij uitgebreide hulp van journalist/historicus Joachim Fest en betrokken partij uitgeverij Siedler. De Duitse historicus Magnus Brechtken, directeur van het Institut für Zeitgeschichte in München, deed in dit verband een oproep om memoires, gedenkboeken en interviews nooit meer aan te wenden bij geschiedschrijving. Zij vormen in het slechtste geval een slinks samenstel van afleidingstrucs, retorische rookgordijnen en onversneden leugens. Een alarmbel in tijden van alom aanwezig nepnieuws.

 Wetenswaardig 
Albert Speer had zes kinderen. Een van zijn zonen, Albert Speer jr. (1934-2017), was eveneens een bekend architect en stadsplanner en ontwerper van voetbalstadions in Qatar voor het WK van 2022.

 Speers publicaties Die neue Reichskanzlei, 1940. Een propagandaboek over de nieuwe Rijkskanselarij die hij voor Hitler gebouwd heeft.Neue deutsche Baukunst, 1941.Erinnerungen, 1969. Een boek dat is samengesteld uit de verschillende notities op onder meer wc-papier die Speer gemaakt heeft tijdens zijn gevangenisperiode in Spandau.Die Spandauer Tagebücher, 1975. Dagboek van Speers gevangenistijd.Der Sklavenstaat. Meine Auseinandersetzungen mit der SS, 1981. Nederlandse vertaling: De slavenstaat. Himmlers SS: de multinational van het Derde Rijk, Elsevier, 1981. Over Speers ervaringen met en zijn verhouding tot Himmlers SS.Alles was ich weiß, 1999. Postume getuigenis van Speer.

 Literatuur 
 Magnus Brechtken, Albert Speer. Eine deutsche Karriere, 2017. (Nederlandse vertaling door Hans E. van Riemsdijk: Albert Speer. Een Duitse carrière, 2018)
 Heinrich Breloer: Unterwegs zur Familie Speer Joachim Fest: Die unbeantwortbaren Fragen. Notizen über Gespräche mit Albert Speer zwischen Ende 1966 und 1981 Interviews met Speer. (vertaling Gerda Meijerink, 2006, Onbeantwoordbare vragen, De Bezige Bij, 256 blz.)
 Joachim Fest: Speer, architect van Hitler, Aula, Amsterdam, 2004, vertaald uit het Duits.
 Joachim Fest: Speer, Eine biographie, Berlin 1999, uitgever Alexander Fest Verlag in Berlijn. .
 Lars Olof Larsson: Albert Speer, Le plan de Berlin, 1937-1943, Brussel, Archives d'Architecture Moderne, 1983.
 Maarten Mahieu, Op de ruïnes van het Derde Rijk. Overblijfselen van de rijkspartijdagen in Neurenberg, in: Eos. Geschiedenis nr 1, najaar 2016.
 Margret Nissen: Sind Sie die Tochter Speer? Matthias Schmidt: Albert Speer, das Ende eines Mythos. De onthulling van achtergehouden documenten over Speers daden in Berlijn en zijn woningpolitiek aldaar, 1982.
 Heinrich Schwendemann: Albert Speer. Architekt des Todes. Speer als de organisator van Duitslands oorlogsindustrie.
 Gitta Sereny: Das Ringen mit der Wahrheit (1995). Vertaald uit het Engels: Albert Speer - His struggle for truth.
 Ulrich Schlie: Die Kransberg-Protokolle 1945 Dan van der Vat: Der gute Nazi. Analyse van Speer als Anständiger nazi.
 Arnoud Veilbrief Kristallnacht? Viel me niet op, in NRC Handelsblad, Cultureel Supplement, 1 september 2006.
 Esther Villar: Speer. (toneelstuk)

Verder bestaat er een boek Die intelligente Stadt, auteur Albert Speer, maar in dit geval betreft het Speers oudste zoon.

 Film 
 Inside the Third Reich (1982): een film gebaseerd op het boek Die Spandauer Tagebücher met Rutger Hauer in de hoofdrol.
 Speer en Hitler (oorspronkelijke titel Speer und Er): een gedramatiseerde documentaire over Albert Speer uit 2004 door Heinrich Breloer.
 Der Untergang'': oorlogsfilm uit 2004, gespeeld door Heino Ferch.

Duits architect
Duits minister van Economie
Duits persoon in de Tweede Wereldoorlog
Minister van nazi-Duitsland
NSDAP-lid

;(function(window) {
  'use strict';

  /** The base path of the lodash builds. */
  var basePath = '../';

  /** The lodash build to load. */
  var build = (build = /build=([^&]+)/.exec(location.search)) && decodeURIComponent(build[1]);

  /** The module loader to use. */
  var loader = (loader = /loader=([^&]+)/.exec(location.search)) && decodeURIComponent(loader[1]);

  /** The `ui` object. */
  var ui = {};

  /*--------------------------------------------------------------------------*/

  // Initialize controls.
  addEventListener('load', function() {
    function eventHandler(event) {
      var buildIndex = buildList.selectedIndex,
          loaderIndex = loaderList.selectedIndex,
          search = location.search.replace(/^\?|&?(?:build|loader)=[^&]*&?/g, '');

      if (event.stopPropagation) {
        event.stopPropagation();
      } else {
        event.cancelBubble = true;
      }
      location.href =
        location.href.split('?')[0] + '?' +
        (search ? search + '&' : '') +
        'build=' + (buildIndex < 0 ? build : buildList[buildIndex].value) + '&' +
        'loader=' + (loaderIndex < 0 ? loader : loaderList[loaderIndex].value);
    }

    function init() {
      var toolbar = document.getElementById('qunit-testrunner-toolbar');
      if (!toolbar) {
        setTimeout(init, 15);
        return;
      }
      toolbar.insertBefore(span2, toolbar.lastChild);
      toolbar.insertBefore(span1, span2);

      buildList.selectedIndex = (function() {
        switch (build) {
          case 'lodash':            return 1;
          case 'lodash-core-dev':   return 2;
          case 'lodash-core':       return 3;
          case 'lodash-dev':
          case null:                return 0;
        }
        return -1;
      }());

      loaderList.selectedIndex = (function() {
        switch (loader) {
          case 'curl':      return 1;
          case 'dojo':      return 2;
          case 'requirejs': return 3;
          case 'none':
          case null:        return 0;
        }
        return -1;
      }());

      buildList.addEventListener('change', eventHandler);
      loaderList.addEventListener('change', eventHandler);
    }

    var span1 = document.createElement('span');
    span1.innerHTML =
      '<label for="qunit-build">Build: </label>' +
      '<select id="qunit-build">' +
      '<option value="lodash-dev">lodash (development)</option>' +
      '<option value="lodash">lodash (production)</option>' +
      '<option value="lodash-core-dev">lodash-core (development)</option>' +
      '<option value="lodash-core">lodash-core (production)</option>' +
      '</select>';

    var span2 = document.createElement('span');
    span2.innerHTML =
      '<label for="qunit-loader">Loader: </label>' +
      '<select id="qunit-loader">' +
      '<option value="none">None</option>' +
      '<option value="curl">Curl</option>' +
      '<option value="dojo">Dojo</option>' +
      '<option value="requirejs">RequireJS</option>' +
      '</select>';

    span1.style.cssText =
    span2.style.cssText = 'display:inline-block;float:right;line-height:2.1em;margin-left:1em;margin-top:0;';

    span1.firstChild.style.cssText =
    span2.firstChild.style.cssText = 'display:inline-block;margin-right:.5em;';

    var buildList = span1.lastChild,
        loaderList = span2.lastChild;

    setTimeout(function() {
      ui.timing.loadEventEnd = +new Date;
    }, 1);

    init();
  });

  // The lodash build file path.
  ui.buildPath = (function() {
    var result;
    switch (build) {
      case 'lodash':            result = 'dist/lodash.min.js'; break;
      case 'lodash-core-dev':   result = 'dist/lodash.core.js'; break;
      case 'lodash-core':       result = 'dist/lodash.core.min.js'; break;
      case null:                build  = 'lodash-dev';
      case 'lodash-dev':        result = 'lodash.js'; break;
      default:                  return build;
    }
    return basePath + result;
  }());

  // The module loader file path.
  ui.loaderPath = (function() {
    var result;
    switch (loader) {
      case 'curl':      result = 'node_modules/curl-amd/dist/curl-kitchen-sink/curl.js'; break;
      case 'dojo':      result = 'node_modules/dojo/dojo.js'; break;
      case 'requirejs': result = 'node_modules/requirejs/require.js'; break;
      case null:        loader = 'none'; return '';
      default:          return loader;
    }
    return basePath + result;
  }());

  // Used to indicate testing a core build.
  ui.isCore = /\bcore(\.min)?\.js\b/.test(ui.buildPath);

  // Used to indicate testing a foreign file.
  ui.isForeign = RegExp('^(\\w+:)?//').test(build);

  // Used to indicate testing a modularized build.
  ui.isModularize = /\b(?:amd|commonjs|es|node|npm|(index|main)\.js)\b/.test([location.pathname, location.search]);

  // Used to indicate testing in Sauce Labs' automated test cloud.
  ui.isSauceLabs = location.port == '9001';

  // Used to indicate that lodash is in strict mode.
  ui.isStrict = /\bes\b/.test([location.pathname, location.search]);

  ui.urlParams = { 'build': build, 'loader': loader };
  ui.timing = { 'loadEventEnd': 0 };

  window.ui = ui;

}(this));

log
===

A Rust library providing a lightweight logging *facade*.

[![Build status](https://img.shields.io/github/actions/workflow/status/rust-lang/log/main.yml?branch=master)](https://github.com/rust-lang/log/actions)
[![Latest version](https://img.shields.io/crates/v/log.svg)](https://crates.io/crates/log)
[![Documentation](https://docs.rs/log/badge.svg)](https://docs.rs/log)
![License](https://img.shields.io/crates/l/log.svg)

* [`log` documentation](https://docs.rs/log)

A logging facade provides a single logging API that abstracts over the actual
logging implementation. Libraries can use the logging API provided by this
crate, and the consumer of those libraries can choose the logging
implementation that is most suitable for its use case.


## Minimum supported `rustc`

See the `rust-version` field in `Cargo.toml` for the current minimum Rust toolchain version.

This version is explicitly tested in CI and may be bumped in any release as needed. Maintaining compatibility with older compilers is a priority though, so the bar for bumping the minimum supported version is set very high. Any changes to the supported minimum version will be called out in the release notes.

## Usage

### In libraries

Libraries should link only to the `log` crate, and use the provided macros to
log whatever information will be useful to downstream consumers:

```toml
[dependencies]
log = "0.4"
```

```rust
use log::{info, trace, warn};

pub fn shave_the_yak(yak: &mut Yak) {
    trace!("Commencing yak shaving");

    loop {
        match find_a_razor() {
            Ok(razor) => {
                info!("Razor located: {razor}");
                yak.shave(razor);
                break;
            }
            Err(err) => {
                warn!("Unable to locate a razor: {err}, retrying");
            }
        }
    }
}
```

### In executables

In order to produce log output, executables have to use a logger implementation compatible with the facade.
There are many available implementations to choose from, here are some options:

* Simple minimal loggers:
    * [`env_logger`](https://docs.rs/env_logger/*/env_logger/)
    * [`colog`](https://docs.rs/colog/*/colog/)
    * [`simple_logger`](https://docs.rs/simple_logger/*/simple_logger/)
    * [`simplelog`](https://docs.rs/simplelog/*/simplelog/)
    * [`pretty_env_logger`](https://docs.rs/pretty_env_logger/*/pretty_env_logger/)
    * [`stderrlog`](https://docs.rs/stderrlog/*/stderrlog/)
    * [`flexi_logger`](https://docs.rs/flexi_logger/*/flexi_logger/)
    * [`call_logger`](https://docs.rs/call_logger/*/call_logger/)
    * [`std-logger`](https://docs.rs/std-logger/*/std_logger/)
    * [`structured-logger`](https://docs.rs/structured-logger/latest/structured_logger/)
    * [`clang_log`](https://docs.rs/clang_log/latest/clang_log)
    * [`ftail`](https://docs.rs/ftail/latest/ftail/)
* Complex configurable frameworks:
    * [`log4rs`](https://docs.rs/log4rs/*/log4rs/)
    * [`logforth`](https://docs.rs/logforth/*/logforth/)
    * [`fern`](https://docs.rs/fern/*/fern/)
    * [`spdlog-rs`](https://docs.rs/spdlog-rs/*/spdlog/)
* Adaptors for other facilities:
    * [`syslog`](https://docs.rs/syslog/*/syslog/)
    * [`systemd-journal-logger`](https://docs.rs/systemd-journal-logger/*/systemd_journal_logger/)
    * [`slog-stdlog`](https://docs.rs/slog-stdlog/*/slog_stdlog/)
    * [`android_log`](https://docs.rs/android_log/*/android_log/)
    * [`win_dbg_logger`](https://docs.rs/win_dbg_logger/*/win_dbg_logger/)
    * [`db_logger`](https://docs.rs/db_logger/*/db_logger/)
    * [`log-to-defmt`](https://docs.rs/log-to-defmt/*/log_to_defmt/)
    * [`logcontrol-log`](https://docs.rs/logcontrol-log/*/logcontrol_log/)
* For WebAssembly binaries:
    * [`console_log`](https://docs.rs/console_log/*/console_log/)
* For dynamic libraries:
    * You may need to construct [an FFI-safe wrapper over `log`](https://github.com/rust-lang/log/issues/421) to initialize in your libraries.
* Utilities:
    * [`log_err`](https://docs.rs/log_err/*/log_err/)
    * [`log-reload`](https://docs.rs/log-reload/*/log_reload/)
    * [`alterable_logger`](https://docs.rs/alterable_logger/*/alterable_logger)
    * [`context-logger`](https://docs.rs/context-logger/*/context_logger)

Executables should choose a logger implementation and initialize it early in the
runtime of the program. Logger implementations will typically include a
function to do this. Any log messages generated before the logger is
initialized will be ignored.

The executable itself may use the `log` crate to log as well.

## Structured logging

If you enable the `kv` feature, you can associate structured data with your log records:

```rust
use log::{info, trace, warn};

pub fn shave_the_yak(yak: &mut Yak) {
    // `yak:serde` will capture `yak` using its `serde::Serialize` impl
    //
    // You could also use `:?` for `Debug`, or `:%` for `Display`. For a
    // full list, see the `log` crate documentation
    trace!(target = "yak_events", yak:serde; "Commencing yak shaving");

    loop {
        match find_a_razor() {
            Ok(razor) => {
                info!(razor; "Razor located");
                yak.shave(razor);
                break;
            }
            Err(e) => {
                // `e:err` will capture `e` using its `std::error::Error` impl
                warn!(e:err; "Unable to locate a razor, retrying");
            }
        }
    }
}
```

est un réalisateur, producteur, scénariste et monteur japonais, né le  à Tokyo, où il est mort le . Il est considéré comme l’un des cinéastes les plus célèbres et influents de l’histoire du cinéma. En cinquante-sept ans de carrière cinématographique, il a réalisé plus de trente films.

Après une brève expérience de peintre, Akira Kurosawa entre dans l’industrie cinématographique japonaise en 1936 en tant qu’assistant réalisateur et scénariste. Il fait ses débuts en tant que réalisateur pendant la Seconde Guerre mondiale avec le film d’action populaire . Son huitième long métrage, , sort en 1948 et est acclamé par la critique, consolidant sa réputation. Ce film marque les débuts de sa collaboration avec l’acteur Toshirō Mifune, qui va tourner dans seize de ses films.

Pour , dont la première a lieu à Tokyo en , Akira Kurosawa reçoit le Lion d’or de la Mostra de Venise. Cette récompense inattendue permet au film d’être diffusé en Europe et en Amérique du Nord. Son succès public et critique ouvre les portes de l’Occident au cinéma japonais et permet à d’autres cinéastes japonais d’obtenir une reconnaissance internationale. Des  au début des , Kurosawa réalise environ un film par an, dont ,  et . Au début des , il devient beaucoup moins prolifique, mais ses œuvres tardives  continuent de remporter des prix, dont la Palme d’or au Festival de Cannes pour Kagemusha.
 
En 1990, il reçoit l’Oscar d’honneur décerné par l’ . En 1999, il est nommé à titre posthume « Personnalité asiatique du siècle » dans la catégorie « Arts, littérature, et culture » par le magazine Asiaweek et CNN, présenté comme .

Biographie

Enfance et éducation cinématographique (1910-1935) 
Kurosawa naît le  dans le quartier de Higashiōi (arrondissement de Shinagawa) à Tokyo. Son père Isamu, descendant d’une famille de samouraïs de la préfecture d’Akita, est directeur de l’école secondaire de l’Institut d’éducation physique de l’armée, tandis que sa mère vient d’une famille de marchands d’Osaka. Il est le benjamin d’une lignée de sept enfants. Deux d’entre eux sont presqu’adultes à sa naissance, et une de ses sœurs meurt peu de temps après. Kurosawa ne grandit alors qu’avec trois de ses frères et sœurs.

En plus de promouvoir l’exercice physique, son père, Isamu Kurosawa, considère la culture occidentale  comme un point essentiel de l’éducation : le jeune Akira découvre le cinéma à l’âge de . Sous l’influence d’un de ses professeurs d’école élémentaire, , il se passionne pour la peinture et le dessin. À cette époque, il étudie également la calligraphie et le kendo.

L’enfance d’Akira Kurosawa est également très influencée par son frère Heigo, de quatre ans son aîné. Kurosawa rapporte qu’à la suite du séisme du Kantō de 1923, Heigo l’emmène dans les quartiers les plus détruits de la capitale et que lorsqu’il tente de détourner les yeux des cadavres jonchant les rues, son frère l’en empêche pour l’obliger à affronter ses peurs. Pour certains critiques, cet événement a fortement influencé la sensibilité de Kurosawa.

Heigo est un élève brillant, mais échoue à son examen d’entrée au lycée. À la suite de cet échec, il se détache peu à peu de sa famille, et se concentre sur la littérature étrangère. À la fin des années 1920, Heigo devient benshi (commentateur de films muets) et se fait connaître sous le nom de Suda Teimei. Akira, qui veut alors devenir peintre de style occidental, emménage avec son frère. Grâce à Heigo, Akira découvre non seulement le cinéma, mais également le théâtre et le cirque. Dans le même temps, il expose ses toiles et travaux dans le cadre des expositions de la Ligue des artistes prolétariens. Mais il n’arrive pas à vivre de sa peinture et finit par s’en lasser. Il se détourne aussi de la politique alors que la répression policière s’est accentuée.

Avec l’avènement du cinéma parlant au début des années 1930, il devient difficile pour les benshi comme Heigo de trouver du travail, et Akira retourne chez ses parents. En , Heigo se suicide avec sa compagne. Kurosawa décrit cette mort comme un sentiment durable de perte, et l’évoque dans le chapitre intitulé « Une histoire dont je ne veux pas parler » de son autobiographie. Seulement quatre mois après la mort de Heigo, son frère aîné meurt également.

Apprentissage de la réalisation (1935-1941) 

En 1935, le nouveau studio de cinéma « Photo Chemical Laboratories »  recherche des assistants réalisateurs. Bien qu’il n’ait jamais envisagé de travailler dans le cinéma et qu’il ait déjà un travail d’illustrateur de livres, Kurosawa répond à l’annonce du studio, qui demande aux candidats de rédiger un essai sur les défauts fondamentaux des films japonais et les moyens d’y remédier. Kurosawa explique dans son papier que si ces défauts sont fondamentaux, alors il n’y a aucun moyen de les corriger. Cette lettre au ton moqueur lui permet de passer les examens suivants. Le réalisateur Kajirō Yamamoto, qui fait partie des recruteurs, insiste pour que Kurosawa soit embauché. En , à l’âge de , Kurosawa entre chez PCL.

Au cours de ses cinq années en tant qu’assistant, Kurosawa travaille pour un nombre important de réalisateurs différents, mais celui qui lui apporte le plus reste Kajirō Yamamoto. Sur ses vingt-quatre films en tant qu’assistant réalisateur, dix-sept sont réalisés par Yamamoto, la plupart étant des comédies jouées par l’acteur Ken’ichi Enomoto, plus connu sous le nom de « Enoken ». Yamamoto cultive le talent de Kurosawa et le fait passer en une année de troisième assistant à « assistant réalisateur en chef ». Les responsabilités de Kurosawa s’accroissent, et son travail va de l’élaboration des scènes et du développement du film aux repérages des lieux de tournage, en passant par la finition du scénario, les répétitions, l’éclairage, le doublage, le montage et la direction de la seconde équipe. Dans son dernier film en tant qu’assistant réalisateur, , Kurosawa prend en charge l’essentiel de la production, Yamamoto étant déjà occupé par le tournage d’un autre film.

Yamamoto confie à Kurosawa qu’un bon réalisateur doit avant tout être un excellent scénariste. Kurosawa comprend alors qu’il peut être davantage rémunéré en écrivant des scénarios plutôt qu’en restant assistant réalisateur. Par la suite, il écrit ou coécrit tous ses films, et écrit fréquemment des scénarios pour d’autres réalisateurs, comme celui du film  de Satsuo Yamamoto. L’écriture de scénarios pour d’autres réalisateurs est pour Kurosawa une activité lucrative, qui dure jusque dans les années 1960, bien après qu’il soit devenu célèbre.

Guerre, censure et mariage (1942-1945) 
Durant les deux ans suivant la sortie de Cheval en 1941, Kurosawa est en quête d’une histoire qui pourrait lancer sa carrière de réalisateur. Vers la fin de l’année 1942, environ un an après le début de la guerre entre le Japon et les États-Unis, le romancier Tsuneo Tomita publie Sugata Sanshirō, un roman sur la naissance du judo écrit dans le style de Miyamoto Musashi. Intrigué par le livre, Kurosawa l’achète le jour de sa publication ; après l’avoir lu d’une traite, il demande immédiatement à la Tōhō d’en acquérir les droits d’adaptation. Son intuition s’est avérée juste puisque, en l’espace de quelques jours, trois autres grands studios japonais proposent également d’acheter les droits. La Tōhō finit par les obtenir, et Kurosawa entame la préproduction de son premier film en tant que réalisateur.

Le tournage de  débute à Yokohama en . La production du film ne pose pas de problème, mais la censure, qui avait donné son accord en amont conformément à la loi sur le cinéma de 1939, juge le résultat du tournage trop . La Légende du grand judo doit finalement sa sortie le  au réalisateur Yasujirō Ozu, qui défend le film. Néanmoins, dix-huit minutes de la version initiale sont censurées. La plupart de ces coupes sont aujourd’hui considérées comme définitivement perdues. La Légende du grand judo est un film caractéristique de l’idéologie de l’époque. Il exalte les vertus morales et l’abnégation du petit peuple, par opposition à l’égoïsme et à la méchanceté des bourgeois occidentalisés, représentés par le personnage de Gennosuke.

Kurosawa s’intéresse ensuite au sujet des femmes ouvrières en temps de guerre dans , un film de propagande tourné dans un style semi-documentaire au début de l’année 1944. Le scénario, écrit par Kurosawa, met en scène un groupe de jeunes ouvrières dans une usine de lentilles optiques à usage militaire qui fait tout son possible malgré les difficultés pour augmenter sa productivité. Pour obtenir des performances réalistes de la part des actrices, Kurosawa les fait vivre dans une véritable usine pendant le tournage, manger la nourriture de l’usine et s’appeler les unes les autres par les noms de leurs personnages. Il utilise des méthodes similaires avec ses interprètes tout au long de sa carrière.

Au cours de la production, Yōko Yaguchi, l’actrice interprétant la meneuse du groupe d’ouvrières, est choisie par ses collègues pour présenter à Kurosawa leurs exigences. Paradoxalement, alors qu’ils s’opposent en permanence, Yaguchi et Kurosawa se rapprochent. Ils se marient le , alors que Yōko est enceinte de deux mois. Ils restent mariés jusqu’à la mort de Yōko en 1985. Ils ont ensemble deux enfants : un fils, Hisao, né le , producteur de quelques-uns des derniers projets de son père, et une fille, Kazuko, née le , chef costumière.

Juste avant son mariage, Kurosawa est pressé par le studio de donner une suite à La Légende du grand judo. Le film de propagande  sort en , et est souvent considéré comme l’une des œuvres les moins abouties de Kurosawa.

Dans le contexte de pénurie des derniers mois de la guerre, Kurosawa décide d’écrire le scénario d’un film moins onéreux à produire que les précédents. , basé sur la pièce de kabuki Kanjinchō, avec Enoken, est achevé en . À cette date, le Japon vient de capituler, et l’occupation du pays par les Alliés a commencé. Le système de censure mis en place par les Américains, à l’encontre de tous les films japonais réalisés pendant la guerre, bloque la diffusion du film, estimant qu’il défend des valeurs . Le film avait déjà été critiqué par les censeurs japonais en temps de guerre, qui le jugeaient trop occidental et . Ils regrettaient notamment le rôle du porteur comique interprété par Enoken. Le film n’aurait donc probablement pas vu le jour même si la guerre s’était poursuivie plus longtemps. Il ne sort finalement qu’en 1952, sept ans après son tournage.

Travaux d'après-guerre (1946-1950) 
Au lendemain de la guerre, Kurosawa est inspiré par les idéaux démocratiques du nouveau régime né de l’occupation. Le premier film résultant de cette inspiration est , sorti en 1946, basé sur l’incident de Takigawa de 1933 et l’affaire de l’espion Hotsumi Ozaki, dans lequel le réalisateur critique le régime japonais d’avant-guerre. Le personnage central du film est une femme, Yukie (interprétée par Setsuko Hara), qui cherche sa place dans un contexte de crise politique. Le scénario original, écrit par Eijirō Hisaita, doit être revu et corrigé de façon importante en raison de ses thèmes politiques. Le film divise la critique, tant par son sujet controversé que par le sexe de son personnage principal. En revanche, le succès auprès du public est présent, et le titre du film devient une phrase culte d’après-guerre.

Son film suivant, , sort en  et reçoit un accueil critique mitigé. Il s’agit de l’histoire d’amour relativement simple d’un couple appauvri par la guerre qui souhaite profiter de son jour de repos. Pour ce film, Kurosawa est influencé par les œuvres de Frank Capra, D. W. Griffith et F. W. Murnau, des cinéastes qu’il admire profondément. En 1947 sort , un film de Senkichi Taniguchi et écrit par Kurosawa. Ce film marque les débuts du jeune acteur Toshirō Mifune. C’est Kurosawa, avec l’aide de Yamamoto, qui insiste pour que le studio Tōhō engage Mifune.

L’année suivante sort . Bien que le scénario doive être réécrit à cause de la censure de l’occupation, Kurosawa a le sentiment de pouvoir enfin s’exprimer librement. Le film raconte l’histoire d’un médecin tentant de sauver un yakuza de la tuberculose. Il s’agit de la première collaboration entre le réalisateur et Mifune. Cette collaboration se poursuit durant les seize films suivants du cinéaste (hormis Vivre), où Mifune joue les premiers rôles. À l’origine, Mifune n’est pas censé jouer le personnage principal de L’Ange ivre, mais sa prestation de yakuza est telle qu’il domine le film et éclipse le rôle du docteur alcoolique tenu par Takashi Shimura. Kurosawa décide alors de ne pas gêner la montée en puissance du jeune acteur. Le jeu de rebelle de Mifune conquiert aussitôt le public. L’avant-première a lieu en , et le film est élu meilleur film de l’année par la prestigieuse revue Kinema Junpō. Au total, trois films de Kurosawa seront ainsi récompensés.

Avec le producteur Sōjirō Motoki et les réalisateurs Kajirō Yamamoto, Mikio Naruse et Senkichi Taniguchi, Kurosawa fonde l’. Pour les débuts de cette organisation, et pour son premier film pour Daiei, Kurosawa adapte avec Taniguchi une pièce contemporaine de Kazuo Kikuta.  a pour tête d’affiche Toshirō Mifune en jeune médecin idéaliste luttant contre la syphilis. Il s’agit d’une tentative délibérée de Kurosawa de sortir Mifune des rôles de gangsters. Sorti en , le film est un succès au box-office, mais est généralement considéré comme l’un des moins bons du cinéaste.

Son second film de l’année 1949, également produit par l’Association artistique cinématographique et distribué par la Shintōhō, est , l’un de ses films les plus célèbres. Ce film policier raconte l’histoire d’un jeune détective (interprété par Mifune) obsédé par son pistolet volé par un démuni qui s’en sert pour commettre des crimes. Il est chargé d’assister le commissaire Sato, dont la perspicacité pour remonter jusqu’au coupable rappelle celle du commissaire Maigret. Adapté d’un roman de Kurosawa lui-même, et écrit dans le style de l’un de ses auteurs favoris , il s’agit avant tout de sa première collaboration avec le scénariste Ryūzō Kikushima. L’une des séquences les plus célèbres du film, d’une durée de huit minutes et sans dialogues, représente le jeune détective déguisé en pauvre vétéran errant dans les rues à la recherche de son arme ; cette séquence utilise des plans d’un documentaire sur la ville de Tokyo ravagée par la guerre, réalisé par Ishirō Honda, un ami de Kurosawa et futur réalisateur de .

, produit par la Shōchiku et sorti en , est inspiré d’une expérience personnelle du réalisateur avec la presse à scandale. Le film mêle drame judiciaire et problèmes sociaux sur fond de liberté d’expression et de responsabilités personnelles. Mais Kurosawa juge le travail flou et peu satisfaisant, rejoignant ce que s’accorde à dire la majorité des critiques. Cependant, c’est avec son second film de 1950, , que Kurosawa finit par gagner un tout nouveau public.

Reconnaissance internationale (1950-1958) 
Après la sortie de Scandale, Kurosawa est approché par les studios Daiei, afin qu’il réalise un deuxième film pour eux après Le Duel silencieux. Le réalisateur choisit alors le script d’un jeune scénariste, Shinobu Hashimoto, basé sur la nouvelle de Ryūnosuke Akutagawa intitulée  qui narre le meurtre d’un samouraï et le viol de sa femme. Kurosawa voit dans cette nouvelle un potentiel cinématographique, et décide de la développer avec l’aide de Hashimoto. Daiei accueille le projet avec enthousiasme d’autant que le budget requis semble faible avec ses deux uniques décors et un tournage majoritairement en extérieur. Matsutarō Kawaguchi, alors cadre à la Daiei, se plaindra plus tard auprès de Kurosawa d’avoir été roulé tant l’imposant décor de la porte Rashō a été couteux.

Le tournage de Rashōmon se déroule du  au  dans les grands espaces montagneux de la forêt de Nara puis dans la forêt qui longe le Konkai kōmyō-ji à Kyoto. La post-production du film dure une seule semaine, et est gênée par un incendie dans les studios. L’avant-première a lieu le  au théâtre impérial de Tokyo, la sortie nationale le lendemain. Les critiques sont partagées, intriguées par le thème unique du film. Il s’agit néanmoins d’un succès financier modéré pour la société Daiei.

Le film suivant de Kurosawa, pour Shōchiku, est , une adaptation du roman de l’écrivain préféré du réalisateur, Fiodor Dostoïevski. Le cinéaste délocalise l’histoire de la Russie à Hokkaidō, mais reste très fidèle à l’œuvre originale, ce que de nombreuses critiques jugent dommageable pour le film. Jugé trop long, le film de Kurosawa est raccourci, passant de  (près de ) à , ce qui rend l’histoire difficilement compréhensible. À sa sortie, les critiques sont très mauvaises, mais le film rencontre un succès modéré auprès du public, essentiellement grâce à la présence de Setsuko Hara.

Pendant ce temps, à l’insu de Kurosawa, Rashōmon est sélectionné à la Mostra de Venise grâce aux efforts de Giuliana Stramigioli, une représentante basée au Japon d’une société de production italienne. Le , Rashōmon reçoit la plus haute distinction du festival, le Lion d’or. Cette récompense surprend l’ensemble du monde du cinéma, qui à l’époque ignorait quasiment tout de la tradition cinématographique du Japon.

Daiei exploite alors brièvement le film à Los Angeles jusqu’à ce que RKO rachète les droits de distribution sur le sol des États-Unis. Le risque est grand pour RKO : à l’époque, un seul film sous-titré est sur le marché américain, et le seul film japonais ayant été distribué à New York, une comédie de Mikio Naruse en 1937, a été un échec critique et commercial. Pourtant, l’exploitation de Rashōmon est un succès, aidée par de nombreux critiques dont Ed Sullivan : lors des trois premières semaines, le film engrange , et ce dans un seul cinéma de New York. Le public français quant à lui découvre le film en salles en . Ce succès entraîne un regain d’intérêt pour les films japonais en Occident dans les , éclipsant le cinéma néoréaliste italien. Grâce à cette renommée, les films d’autres cinéastes japonais commencent à recevoir des récompenses et à être distribués en Occident, comme ceux de Kenji Mizoguchi, et plus tard ceux de Yasujirō Ozu, des cinéastes reconnus au Japon mais totalement inconnus dans cette partie du monde.

Sa carrière gonflée par sa reconnaissance internationale, Kurosawa retourne chez Tōhō et travaille sur son prochain film, . Le film met en scène Watanabe (Takashi Shimura), un fonctionnaire atteint d’un cancer qui cherche à donner un dernier sens à sa vie. Pour le scénario, Kurosawa s’allie à Hashimoto et à l’écrivain Hideo Oguni, avec qui il coécrit douze films. Malgré le sujet grave, les scénaristes abordent le récit d’une manière satirique, ce que certains comparent au travail de Bertolt Brecht. Cette stratégie leur a permis d’éviter ce sentimentalisme commun qui règne habituellement autour de personnages atteints de maladies incurables. Vivre sort en , Kurosawa est récompensé de son deuxième « meilleur film » de Kinema Junpō, et le film remporte un grand succès au box-office.

En , Kurosawa s’isole durant  avec les deux scénaristes de Ikiru, Shinobu Hashimoto et Hideo Oguni. Ensemble, ils écrivent le scénario du prochain film du cinéaste, . Il s’agit du premier véritable chanbara de Kurosawa, genre pour lequel il est aujourd’hui le plus connu. L’histoire, celle d’un pauvre village de l’époque Sengoku qui fait appel à un groupe de samouraïs afin de se défendre des bandits, est traitée par Kurosawa d’une manière totalement épique, et l’action est méticuleusement détaillée durant les trois heures et demie. Le film s’appuie sur une distribution d’ensemble impressionnante, composée notamment d’acteurs ayant déjà tourné avec Kurosawa.

Trois mois sont nécessaires pour la préproduction, un mois pour les répétitions. Le tournage dure  étalés sur près d’un an, interrompu entre autres par des difficultés de production et d’ordre financier, ainsi que par les problèmes de santé de Kurosawa. Le film sort finalement en , soit  après la date prévue. Le film coûte trois fois plus que prévu, et devient alors le film japonais le plus cher jamais réalisé. Les critiques sont positives, et le succès au box-office permet de rentrer rapidement dans les frais. Après de nombreuses modifications, il est distribué sur le marché international. Au fil du temps, et grâce aux versions non modifiées diffusées par la suite, le film accroît sa notoriété. En 1979, un vote parmi des critiques japonais le classe comme étant le meilleur film japonais de tous les temps. Aujourd’hui encore, il est considéré comme tel par certains critiques.

En 1954, des tests nucléaires militaires dans le Pacifique créent des incidents aux conséquences désastreuses, comme celui impliquant le thonier japonais Daigo Fukuryū Maru. C’est dans cette anxiété ambiante que Kurosawa conçoit son film suivant, . Le propos porte sur un riche industriel (Toshirō Mifune) terrifié à l’idée d’une attaque nucléaire, et qui décide d’emmener sa famille dans une ferme au Brésil pour être en sécurité. La production est moins chaotique que lors du film précédent, mais à quelques jours de la fin du tournage, Fumio Hayasaka, compositeur et ami de Kurosawa, meurt de la tuberculose. La bande originale est alors achevée par l’assistant de Hayasaka, Masaru Satō, qui travaille sur les huit films suivants de Kurosawa. Vivre dans la peur sort en , mais l’accueil des critiques et du public est timide et réservé. Le film devient alors le premier de Kurosawa à ne pas rentrer dans ses frais durant son exploitation en salle. Aujourd’hui, il est considéré comme le meilleur film traitant des effets psychologiques de la paralysie nucléaire mondiale.

Le projet suivant de Kurosawa, , est une adaptation du Macbeth de William Shakespeare, dont l’histoire est transposée en Asie à l’époque Sengoku. Kurosawa donne pour instruction aux acteurs, et notamment à l’actrice principale Isuzu Yamada, d’agir et de jouer comme s’il s’agissait d’un classique de la littérature japonaise et non occidentale. Le jeu des acteurs s’apparente alors aux techniques et styles du théâtre nô. Le film est tourné en 1956 et sort en . Le succès en salle est légèrement moins mauvais que pour Vivre dans la peur. À l’étranger, le film devient rapidement une référence parmi les adaptations cinématographiques de Shakespeare.

La production d’une autre adaptation d’un classique européen suit immédiatement celle du Château de l’araignée. , adapté de la pièce du même nom de Maxime Gorki, est réalisé en mai et . Bien que l’adaptation soit très fidèle à la pièce de théâtre russe, l’exercice de transposition à l’époque d’Edo est considéré comme une réussite artistique. La première a lieu en , et le film reçoit un accueil partagé, similaire à celui reçu par Le Château de l’araignée. Certains critiques le classent parmi les œuvres les plus sous-estimées de Kurosawa.

Les trois films suivant Les Sept Samouraïs n’ont pas connu le même succès auprès du public japonais. Le travail de Kurosawa est de plus en plus sombre et pessimiste, et le réalisateur aborde les questions de la rédemption. Kurosawa, qui s’aperçoit de ces changements, décide délibérément de retourner à des films plus légers et divertissants. À cette même époque, le format écran large devient très populaire au Japon. En résulte , film d’action et d’aventure mettant en scène une princesse, son fidèle général et deux paysans devant traverser les lignes ennemies pour pouvoir rejoindre leurs foyers. Sorti en 1958, La Forteresse cachée est un énorme succès au box-office, et est chaudement accueilli par les critiques. Aujourd’hui, le film est considéré comme l’un des films les plus légers et accessibles de Kurosawa, mais reste très populaire pour ses nombreuses influences, notamment sur Star Wars, le  de George Lucas sorti en 1977.

Naissance d'une entreprise et fin d'une ère (1959-1965) 
Depuis Rashōmon, les films de Kurosawa atteignent un public plus large, et la fortune du réalisateur a

# Contributing to Lodash

Contributions are always welcome. Before contributing please read the
[code of conduct](https://github.com/openjs-foundation/cross-project-council/blob/main/CODE_OF_CONDUCT.md) &
[search the issue tracker](https://github.com/lodash/lodash/issues); your issue
may have already been discussed or fixed in `master`. To contribute,
[fork](https://help.github.com/articles/fork-a-repo/) Lodash, commit your changes,
& [send a pull request](https://help.github.com/articles/using-pull-requests/).

## Feature Requests

Feature requests should be submitted in the
[issue tracker](https://github.com/lodash/lodash/issues), with a description of
the expected behavior & use case, where they’ll remain closed until sufficient interest,
[e.g. :+1: reactions](https://help.github.com/articles/about-discussions-in-issues-and-pull-requests/),
has been [shown by the community](https://github.com/lodash/lodash/issues?q=label%3A%22votes+needed%22+sort%3Areactions-%2B1-desc).
Before submitting a request, please search for similar ones in the
[closed issues](https://github.com/lodash/lodash/issues?q=is%3Aissue+is%3Aclosed+label%3Aenhancement).

## Pull Requests

For additions or bug fixes you should only need to modify `lodash.js`. Include
updated unit tests in the `test` directory as part of your pull request. Don’t
worry about regenerating the `dist/` or `doc/` files.

Before running the unit tests you’ll need to install, `npm i`,
[development dependencies](https://docs.npmjs.com/files/package.json#devdependencies).
Run unit tests from the command-line via `npm test`, or open `test/index.html` &
`test/fp.html` in a web browser. The [Backbone](http://backbonejs.org/) &
[Underscore](http://underscorejs.org/) test suites are included as well.

## Contributor License Agreement

Lodash is a member of the [Open JS Foundation](https://openjsf.org/).
As such, we request that all contributors sign our
[contributor license agreement (CLA)](https://openjsf.org/cla).

For more information about CLAs, please check out Alex Russell’s excellent post,
[“Why Do I Need to Sign This?”](https://infrequently.org/2008/06/why-do-i-need-to-sign-this/).

## Coding Guidelines

In addition to the following guidelines, please follow the conventions already
established in the code.

- **Spacing**:<br>
  Use two spaces for indentation. No tabs.

- **Naming**:<br>
  Keep variable & method names concise & descriptive.<br>
  Variable names `index`, `array`, & `iteratee` are preferable to
  `i`, `arr`, & `fn`.

- **Quotes**:<br>
  Single-quoted strings are preferred to double-quoted strings; however,
  please use a double-quoted string if the value contains a single-quote
  character to avoid unnecessary escaping.

- **Comments**:<br>
  Please use single-line comments to annotate significant additions, &
  [JSDoc-style](http://www.2ality.com/2011/08/jsdoc-intro.html) comments for
  functions.

Guidelines are enforced using [JSCS](https://www.npmjs.com/package/jscs):
```bash
$ npm run style
```

## Tips

You can opt-in to a pre-push git hook by adding an `.opt-in` file to the root of
the project containing:
```txt
pre-push
```

With that, when you `git push`, the pre-push git hook will trigger and execute
`npm run validate`.

> [!IMPORTANT]
> As announced on the [OpenJS Foundation blog](https://openjsf.org/blog/sta-supports-lodash), Lodash has received support from the Sovereign Tech Agency and will transition to the Feature-Complete maturity stage so that it remains stable, secure, and sustainable long-term. As part of this effort, Lodash is rebooting its governance. A draft charter will be published shortly. The upcoming Technical Steering Committee (TSC) is already at work. For transparency, its members are listed below.

# Lodash Governance

## Technical Steering Committee Members

The current Technical Steering Committee (TSC) members are:

- John-David Dalton ([@jdalton](https://github.com/jdalton)), _(Lodash creator)_
- Jon Church ([@jonchurch](https://github.com/jonchurch))
- Jordan Harband ([@ljharb](https://github.com/ljharb))
- Michał Lipiński ([@falsyvalues](https://github.com/falsyvalues))
- Tobie Langel ([@tobie](https://github.com/tobie))
- Ulises Gascón ([@ulisesgascon](https://github.com/UlisesGascon))

## Security Triage Team

The Security Triage Team is responsible for assessing and managing vulnerability and incident reports. Security triaging is currently handled by the [TSC](#technical-steering-committee-members).

## Release Team

The Release Team is solely responsible for publishing new versions of Lodash to npm. Its current member is:

- John-David Dalton ([@jdalton](https://github.com/jdalton))

(handling-files)=

# Handling Files

```{currentmodule} click
```

Click has built in features to support file and file path handling. The examples use arguments but the same principle
applies to options as well.

(file-args)=

## File Arguments

Click supports working with files with the {class}`File` type. Some notable features are:

- Support for `-` to mean a special file that refers to stdin when used for reading, and stdout when used for writing.
  This is a common pattern for POSIX command line utilities.
- Deals with `str` and `bytes` correctly for all versions of Python.

Example:

```{eval-rst}
.. click:example::

    @click.command()
    @click.argument('input', type=click.File('rb'))
    @click.argument('output', type=click.File('wb'))
    def inout(input, output):
        """Copy contents of INPUT to OUTPUT."""
        while True:
            chunk = input.read(1024)
            if not chunk:
                break
            output.write(chunk)

And from the command line:

.. click:run::

    with isolated_filesystem():
        invoke(inout, args=['-', 'hello.txt'], input=['hello'],
               terminate_input=True)
        invoke(inout, args=['hello.txt', '-'])
```

## File Path Arguments

For handling paths, the {class}`Path` type is better than a `str`. Some notable features are:

- The `exists` argument will verify whether the path exists.
- `readable`, `writable`, and `executable` can perform permission checks.
- `file_okay` and `dir_okay` allow specifying whether files/directories are accepted.
- Error messages are nicely formatted using {func}`format_filename` so any undecodable bytes will be printed nicely.

See {class}`Path` for all features.

Example:

```{eval-rst}
.. click:example::

    @click.command()
    @click.argument('filename', type=click.Path(exists=True))
    def touch(filename):
        """Print FILENAME if the file exists."""
        click.echo(click.format_filename(filename))

And from the command line:

.. click:run::

    with isolated_filesystem():
        with open('hello.txt', 'w') as f:
            f.write('Hello World!\n')
        invoke(touch, args=['hello.txt'])
        println()
        invoke(touch, args=['missing.txt'])
```

## File Opening Behaviors

The {class}`File` type attempts to be "intelligent" about when to open a file. Stdin/stdout and files opened for reading
will be opened immediately. This will give the user direct feedback when a file cannot be opened. Files opened for
writing will only be open on the first IO operation. This is done by automatically wrapping the file in a special
wrapper.

File open behavior can be controlled by the boolean kwarg `lazy`. If a file is opened lazily:

- A failure at first IO operation will happen by raising an {exc}`FileError`.
- It can help minimize resource handling confusion by lazily closing it. This is not needed for
  parameters, but is necessary for manually prompting. For manual prompts with the {func}`prompt` function you do not
  know if a stream like stdout was opened (which was already open before) or a real file was opened (that needs
  closing).

Since files opened for writing will typically empty the file, the lazy mode should only be disabled if the developer is
absolutely sure that this is intended behavior.

It is also possible to open files in atomic mode by passing `atomic=True`. In atomic mode, all writes go into a separate
file in the same folder, and upon completion, the file will be moved over to the original location. This is useful if a
file regularly read by other users is modified.

//              Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
//   (See accompanying file LICENSE.txt or copy at
//        https://www.boost.org/LICENSE_1_0.txt)

// SPDX-License-Identifier: BSL-1.0

/**\file
 * Checks that test cases with identical name and tags are reported as error
 */

#include <catch2/catch_test_macros.hpp>

TEST_CASE("A test case with duplicated name and tags", "[tag1][tag2]") {}
TEST_CASE("A test case with duplicated name and tags", "[tag1][tag2]") {}

# Security Policy

## Supported versions

The following table describes the versions of this project that are currently
supported with security updates:

| Version | Supported          |
| ------- | ------------------ |
| 4.x   | :white_check_mark:   |
| 3.x   | :x:                  |
| 2.x   | :x:                  |
| 1.x   | :x:                  |

## Threat Model

To better understand which classes of vulnerabilities are considered in-scope or out-of-scope for Lodash, please review the [Lodash Threat Model](./threat-model.md).

The threat model defines Lodash’s trust boundaries and clarifies how security issues are assessed for triage and disclosure.

## Responsible disclosure security policy

A responsible disclosure policy helps protect users of the project from publicly
disclosed security vulnerabilities without a fix by employing a process where
vulnerabilities are first triaged in a private manner, and only publicly disclosed
after a reasonable time period that allows patching the vulnerability and provides
an upgrade path for users.

We kindly ask you to refrain from malicious acts that put our users, the project,
or any of the project’s team members at risk.

## Reporting a security issue

We consider the security of Lodash a top priority. But no matter how much effort
we put into security, there can still be vulnerabilities present.

If you discover a security vulnerability, please report the security issue
directly to the Lodash maintainers through the [Security tab](https://github.com/lodash/lodash/security) of the Lodash
repository.

Your efforts to responsibly disclose your findings are sincerely appreciated.

## Escalation

If you do not receive an acknowledgement of your report within 6 business days, or if you cannot find a private security contact for the project, you may escalate to the OpenJS Foundation CNA at `security@lists.openjsf.org`.

If the project acknowledges your report but does not provide any further response or engagement within 14 days, escalation is also appropriate.

# Supporting Multiple Versions

If you are a library maintainer, you may want to support multiple versions of
Click. See the Pallets [version policy] for information about our version
numbers and support policy.

[version policy]: https://palletsprojects.com/versions

Most features of Click are stable across releases, and don't require special
handling. However, feature releases may deprecate and change APIs. Occasionally,
a change will require special handling.

## Use Feature Detection

Prefer using feature detection. Looking at the version can be tempting, but is
often more brittle or results in more complicated code. Try to use `if` or `try`
blocks to decide whether to use a new or old pattern.

If you do need to look at the version, use {func}`importlib.metadata.version`,
the standardized way to get versions for any installed Python package.

## Changes in 8.2

### `ParamType` methods require `ctx`

In 8.2, several methods of `ParamType` now have a `ctx: click.Context`
argument. Because this changes the signature of the methods from 8.1, it's not
obvious how to support both when subclassing or calling.

This example uses `ParamType.get_metavar`, and the same technique should be
applicable to other methods such as `get_missing_message`.

Update your methods overrides to take the new `ctx` argument. Use the
following decorator to wrap each method. In 8.1, it will get the context where
possible and pass it using the 8.2 signature.

```python
import functools
import typing as t
import click

F = t.TypeVar("F", bound=t.Callable[..., t.Any])

def add_ctx_arg(f: F) -> F:
    @functools.wraps(f)
    def wrapper(*args: t.Any, **kwargs: t.Any) -> t.Any:
        if "ctx" not in kwargs:
            kwargs["ctx"] = click.get_current_context(silent=True)

        return f(*args, **kwargs)

    return wrapper  # type: ignore[return-value]
```

Here's an example ``ParamType`` subclass which uses this:

```python
class CommaDelimitedString(click.ParamType[str]):
    @add_ctx_arg
    def get_metavar(self, param: click.Parameter, ctx: click.Context | None) -> str:
        return "TEXT,TEXT,..."
```

//              Copyright Catch2 Authors
// Distributed under the Boost Software License, Version 1.0.
//   (See accompanying file LICENSE.txt or copy at
//        https://www.boost.org/LICENSE_1_0.txt)

// SPDX-License-Identifier: BSL-1.0

// 231-Cfg-OutputStreams.cpp
// Show how to replace the streams with a simple custom made streambuf.

// Note that this reimplementation _does not_ follow `std::cerr`
// semantic, because it buffers the output. For most uses however,
// there is no important difference between having `std::cerr` buffered
// or unbuffered.
#include <catch2/catch_test_macros.hpp>

#include <sstream>
#include <cstdio>

class out_buff : public std::stringbuf {
    std::FILE* m_stream;
public:
    out_buff(std::FILE* stream):m_stream(stream) {}
    ~out_buff() override;
    int sync() override {
        int ret = 0;
        for (unsigned char c : str()) {
            if (putc(c, m_stream) == EOF) {
                ret = -1;
                break;
            }
        }
        // Reset the buffer to avoid printing it multiple times
        str("");
        return ret;
    }
};

out_buff::~out_buff() { pubsync(); }

#if defined(__clang__)
#pragma clang diagnostic ignored "-Wexit-time-destructors" // static variables in cout/cerr/clog
#endif

namespace Catch {
    std::ostream& cout() {
        static std::ostream ret(new out_buff(stdout));
        return ret;
    }
    std::ostream& clog() {
        static std::ostream ret(new out_buff(stderr));
        return ret;
    }
    std::ostream& cerr() {
        return clog();
    }
}


TEST_CASE("This binary uses putc to write out output", "[compilation-only]") {
    SUCCEED("Nothing to test.");
}

;(function() {
  'use strict';

  /** Used as a safe reference for `undefined` in pre-ES5 environments. */
  var undefined;

  /** Used as the size to cover large array optimizations. */
  var LARGE_ARRAY_SIZE = 200;

  /** Used as a reference to the global object. */
  var root = (typeof global == 'object' && global) || this;

  /** Used for native method references. */
  var arrayProto = Array.prototype;

  /** Method and object shortcuts. */
  var phantom = root.phantom,
      argv = root.process && process.argv,
      document = !phantom && root.document,
      slice = arrayProto.slice,
      WeakMap = root.WeakMap;

  /** Math helpers. */
  var add = function(x, y) { return x + y; },
      isEven = function(n) { return n % 2 == 0; },
      isEvenIndex = function(n, index) { return isEven(index); },
      square = function(n) { return n * n; };

  // Leak to avoid sporadic `noglobals` fails on Edge in Sauce Labs.
  root.msWDfn = undefined;

  /*--------------------------------------------------------------------------*/

  /** Load QUnit and extras. */
  var QUnit = root.QUnit || require('qunit-extras');

  /** Load stable Lodash. */
  var _ = root._ || require('../lodash.js');

  var convert = (function() {
    var baseConvert = root.fp || require('../fp/_baseConvert.js');
    if (!root.fp) {
      return function(name, func, options) {
        return baseConvert(_, name, func, options);
      };
    }
    return function(name, func, options) {
      if (typeof name == 'function') {
        options = func;
        func = name;
        name = undefined;
      }
      return name === undefined
        ? baseConvert(func, options)
        : baseConvert(_.runInContext(), options)[name];
    };
  }());

  var allFalseOptions = {
    'cap': false,
    'curry': false,
    'fixed': false,
    'immutable': false,
    'rearg': false
  };

  var fp = root.fp
    ? (fp = _.noConflict(), _ = root._, fp)
    : convert(_.runInContext());

  var mapping = root.mapping || require('../fp/_mapping.js');

  /*--------------------------------------------------------------------------*/

  /**
   * Skips a given number of tests with a passing result.
   *
   * @private
   * @param {Object} assert The QUnit assert object.
   * @param {number} [count=1] The number of tests to skip.
   */
  function skipAssert(assert, count) {
    count || (count = 1);
    while (count--) {
      assert.ok(true, 'test skipped');
    }
  }

  /*--------------------------------------------------------------------------*/

  if (argv) {
    console.log('Running lodash/fp tests.');
  }

  QUnit.module('convert module');

  (function() {
    QUnit.test('should work with `name` and `func`', function(assert) {
      assert.expect(2);

      var array = [1, 2, 3, 4],
          remove = convert('remove', _.remove),
          actual = remove(isEven)(array);

      assert.deepEqual(array, [1, 2, 3, 4]);
      assert.deepEqual(actual, [1, 3]);
    });

    QUnit.test('should work with `name`, `func`, and `options`', function(assert) {
      assert.expect(3);

      var array = [1, 2, 3, 4],
          remove = convert('remove', _.remove, allFalseOptions);

      var actual = remove(array, function(n, index) {
        return isEven(index);
      });

      assert.deepEqual(array, [2, 4]);
      assert.deepEqual(actual, [1, 3]);
      assert.deepEqual(remove(), []);
    });

    QUnit.test('should work with an object', function(assert) {
      assert.expect(2);

      if (!document) {
        var array = [1, 2, 3, 4],
            lodash = convert({ 'remove': _.remove }),
            actual = lodash.remove(isEven)(array);

        assert.deepEqual(array, [1, 2, 3, 4]);
        assert.deepEqual(actual, [1, 3]);
      }
      else {
        skipAssert(assert, 2);
      }
    });

    QUnit.test('should work with an object and `options`', function(assert) {
      assert.expect(3);

      if (!document) {
        var array = [1, 2, 3, 4],
            lodash = convert({ 'remove': _.remove }, allFalseOptions),
            actual = lodash.remove(array, isEvenIndex);

        assert.deepEqual(array, [2, 4]);
        assert.deepEqual(actual, [1, 3]);
        assert.deepEqual(lodash.remove(), []);
      }
      else {
        skipAssert(assert, 3);
      }
    });

    QUnit.test('should work with lodash and `options`', function(assert) {
      assert.expect(3);

      var array = [1, 2, 3, 4],
          lodash = convert(_.runInContext(), allFalseOptions),
          actual = lodash.remove(array, isEvenIndex);

      assert.deepEqual(array, [2, 4]);
      assert.deepEqual(actual, [1, 3]);
      assert.deepEqual(lodash.remove(), []);
    });

    QUnit.test('should work with `runInContext` and `options`', function(assert) {
      assert.expect(3);

      var array = [1, 2, 3, 4],
          runInContext = convert('runInContext', _.runInContext, allFalseOptions),
          lodash = runInContext(),
          actual = lodash.remove(array, isEvenIndex);

      assert.deepEqual(array, [2, 4]);
      assert.deepEqual(actual, [1, 3]);
      assert.deepEqual(lodash.remove(), []);
    });

    QUnit.test('should accept a variety of options', function(assert) {
      assert.expect(8);

      var array = [1, 2, 3, 4],
          value = _.clone(array),
          remove = convert('remove', _.remove, { 'cap': false }),
          actual = remove(isEvenIndex)(value);

      assert.deepEqual(value, [1, 2, 3, 4]);
      assert.deepEqual(actual, [2, 4]);

      remove = convert('remove', _.remove, { 'curry': false });
      actual = remove(isEven);

      assert.deepEqual(actual, []);

      var trim = convert('trim', _.trim, { 'fixed': false });
      assert.strictEqual(trim('_-abc-_', '_-'), 'abc');

      value = _.clone(array);
      remove = convert('remove', _.remove, { 'immutable': false });
      actual = remove(isEven)(value);

      assert.deepEqual(value, [1, 3]);
      assert.deepEqual(actual, [2, 4]);

      value = _.clone(array);
      remove = convert('remove', _.remove, { 'rearg': false });
      actual = remove(value)(isEven);

      assert.deepEqual(value, [1, 2, 3, 4]);
      assert.deepEqual(actual, [1, 3]);
    });

    QUnit.test('should respect the `cap` option', function(assert) {
      assert.expect(1);

      var iteratee = convert('iteratee', _.iteratee, { 'cap': false });

      var func = iteratee(function(a, b, c) {
        return [a, b, c];
      }, 3);

      assert.deepEqual(func(1, 2, 3), [1, 2, 3]);
    });

    QUnit.test('should respect the `rearg` option', function(assert) {
      assert.expect(1);

      var add = convert('add', _.add, { 'rearg': true });

      assert.strictEqual(add('2')('1'), '12');
    });

    QUnit.test('should add a `placeholder` property', function(assert) {
      assert.expect(2);

      if (!document) {
        var lodash = convert({ 'add': _.add });

        assert.strictEqual(lodash.placeholder, lodash);
        assert.strictEqual(lodash.add.placeholder, lodash);
      }
      else {
        skipAssert(assert, 2);
      }
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('method.convert');

  (function() {
    QUnit.test('should exist on unconverted methods', function(assert) {
      assert.expect(2);

      var array = [],
          isArray = fp.isArray.convert({ 'curry': true });

      assert.strictEqual(fp.isArray(array), true);
      assert.strictEqual(isArray()(array), true);
    });

    QUnit.test('should convert method aliases', function(assert) {
      assert.expect(1);

      var all = fp.all.convert({ 'rearg': false }),
          actual = all([0])(_.identity);

      assert.strictEqual(actual, false);
    });

    QUnit.test('should convert remapped methods', function(assert) {
      assert.expect(1);

      var extendAll = fp.extendAll.convert({ 'immutable': false }),
          object = {};

      extendAll([object, { 'a': 1 }, { 'b': 2 }]);
      assert.deepEqual(object, { 'a': 1, 'b': 2 });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('convert methods');

  _.each(['fp.convert', 'method.convert'], function(methodName) {
    var isFp = methodName == 'fp.convert',
        func = isFp ? fp.convert : fp.remove.convert;

    QUnit.test('`' + methodName + '` should work with an object', function(assert) {
      assert.expect(3);

      var array = [1, 2, 3, 4],
          lodash = func(allFalseOptions),
          remove = isFp ? lodash.remove : lodash,
          actual = remove(array, isEvenIndex);

      assert.deepEqual(array, [2, 4]);
      assert.deepEqual(actual, [1, 3]);
      assert.deepEqual(remove(), []);
    });

    QUnit.test('`' + methodName + '` should extend existing configs', function(assert) {
      assert.expect(2);

      var array = [1, 2, 3, 4],
          lodash = func({ 'cap': false }),
          remove = (isFp ? lodash.remove : lodash).convert({ 'rearg': false }),
          actual = remove(array)(isEvenIndex);

      assert.deepEqual(array, [1, 2, 3, 4]);
      assert.deepEqual(actual, [2, 4]);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('method arity checks');

  (function() {
    QUnit.test('should wrap methods with an arity > `1`', function(assert) {
      assert.expect(1);

      var methodNames = _.filter(_.functions(fp), function(methodName) {
        return fp[methodName].length > 1;
      });

      assert.deepEqual(methodNames, []);
    });

    QUnit.test('should have >= arity of `aryMethod` designation', function(assert) {
      assert.expect(4);

      _.times(4, function(index) {
        var aryCap = index + 1;

        var methodNames = _.filter(mapping.aryMethod[aryCap], function(methodName) {
          var key = _.get(mapping.remap, methodName, methodName),
              arity = _[key].length;

          return arity != 0 && arity < aryCap;
        });

        assert.deepEqual(methodNames, [], '`aryMethod[' + aryCap + ']`');
      });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('method aliases');

  (function() {
    QUnit.test('should have correct aliases', function(assert) {
      assert.expect(1);

      var actual = _.transform(mapping.aliasToReal, function(result, realName, alias) {
        result.push([alias, fp[alias] === fp[realName]]);
      }, []);

      assert.deepEqual(_.reject(actual, 1), []);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('method ary caps');

  (function() {
    QUnit.test('should have a cap of 1', function(assert) {
      assert.expect(1);

      var funcMethods = [
        'curry', 'iteratee', 'memoize', 'over', 'overEvery', 'overSome',
        'method', 'methodOf', 'rest', 'runInContext'
      ];

      var exceptions = funcMethods.concat('mixin', 'nthArg', 'template'),
          expected = _.map(mapping.aryMethod[1], _.constant(true));

      var actual = _.map(mapping.aryMethod[1], function(methodName) {
        var arg = _.includes(funcMethods, methodName) ? _.noop : 1,
            result = _.attempt(function() { return fp[methodName](arg); });

        if (_.includes(exceptions, methodName)
              ? typeof result == 'function'
              : typeof result != 'function'
            ) {
          return true;
        }
        console.log(methodName, result);
        return false;
      });

      assert.deepEqual(actual, expected);
    });

    QUnit.test('should have a cap of 2', function(assert) {
      assert.expect(1);

      var funcMethods = [
        'after', 'ary', 'before', 'bind', 'bindKey', 'curryN', 'debounce',
        'delay', 'overArgs', 'partial', 'partialRight', 'rearg', 'throttle',
        'wrap'
      ];

      var exceptions = _.without(funcMethods.concat('matchesProperty'), 'delay'),
          expected = _.map(mapping.aryMethod[2], _.constant(true));

      var actual = _.map(mapping.aryMethod[2], function(methodName) {
        var args = _.includes(funcMethods, methodName) ? [methodName == 'curryN' ? 1 : _.noop, _.noop] : [1, []],
            result = _.attempt(function() { return fp[methodName](args[0])(args[1]); });

        if (_.includes(exceptions, methodName)
              ? typeof result == 'function'
              : typeof result != 'function'
            ) {
          return true;
        }
        console.log(methodName, result);
        return false;
      });

      assert.deepEqual(actual, expected);
    });

    QUnit.test('should have a cap of 3', function(assert) {
      assert.expect(1);

      var funcMethods = [
        'assignWith', 'extendWith', 'isEqualWith', 'isMatchWith', 'reduce',
        'reduceRight', 'transform', 'zipWith'
      ];

      var expected = _.map(mapping.aryMethod[3], _.constant(true));

      var actual = _.map(mapping.aryMethod[3], function(methodName) {
        var args = _.includes(funcMethods, methodName) ? [_.noop, 0, 1] : [0, 1, []],
            result = _.attempt(function() { return fp[methodName](args[0])(args[1])(args[2]); });

        if (typeof result != 'function') {
          return true;
        }
        console.log(methodName, result);
        return false;
      });

      assert.deepEqual(actual, expected);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('methods that use `indexOf`');

  (function() {
    QUnit.test('should work with `fp.indexOf`', function(assert) {
      assert.expect(10);

      var array = ['a', 'b', 'c'],
          other = ['b', 'd', 'b'],
          object = { 'a': 1, 'b': 2, 'c': 2 },
          actual = fp.difference(array)(other);

      assert.deepEqual(actual, ['a', 'c'], 'fp.difference');

      actual = fp.includes('b')(array);
      assert.strictEqual(actual, true, 'fp.includes');

      actual = fp.intersection(other)(array);
      assert.deepEqual(actual, ['b'], 'fp.intersection');

      actual = fp.omit(other)(object);
      assert.deepEqual(actual, { 'a': 1, 'c': 2 }, 'fp.omit');

      actual = fp.union(other)(array);
      assert.deepEqual(actual, ['a', 'b', 'c', 'd'], 'fp.union');

      actual = fp.uniq(other);
      assert.deepEqual(actual, ['b', 'd'], 'fp.uniq');

      actual = fp.uniqBy(_.identity, other);
      assert.deepEqual(actual, ['b', 'd'], 'fp.uniqBy');

      actual = fp.without(other)(array);
      assert.deepEqual(actual, ['a', 'c'], 'fp.without');

      actual = fp.xor(other)(array);
      assert.deepEqual(actual, ['a', 'c', 'd'], 'fp.xor');

      actual = fp.pull('b')(array);
      assert.deepEqual(actual, ['a', 'c'], 'fp.pull');
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('cherry-picked methods');

  (function() {
    QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
      assert.expect(4);

      var args,
          array = [1, 2, 3],
          object = { 'a': 1, 'b': 2 },
          isFIFO = _.keys(object)[0] == 'a',
          map = convert('map', _.map),
          reduce = convert('reduce', _.reduce);

      map(function() {
        args || (args = slice.call(arguments));
      })(array);

      assert.deepEqual(args, [1]);

      args = undefined;
      map(function() {
        args || (args = slice.call(arguments));
      })(object);

      assert.deepEqual(args, isFIFO ? [1] : [2]);

      args = undefined;
      reduce(function() {
        args || (args = slice.call(arguments));
      })(0)(array);

      assert.deepEqual(args, [0, 1]);

      args = undefined;
      reduce(function() {
        args || (args = slice.call(arguments));
      })(0)(object);

      assert.deepEqual(args, isFIFO ? [0, 1] : [0, 2]);
    });

    QUnit.test('should not support shortcut fusion', function(assert) {
      assert.expect(3);

      var array = fp.range(0, LARGE_ARRAY_SIZE),
          filterCount = 0,
          mapCount = 0;

      var iteratee = function(value) {
        mapCount++;
        return value * value;
      };

      var predicate = function(value) {
        filterCount++;
        return isEven(value);
      };

      var map1 = convert('map', _.map),
          filter1 = convert('filter', _.filter),
          take1 = convert('take', _.take);

      var filter2 = filter1(predicate),
          map2 = map1(iteratee),
          take2 = take1(2);

      var combined = fp.flow(map2, filter2, fp.compact, take2);

      assert.deepEqual(combined(array), [4, 16]);
      assert.strictEqual(filterCount, 200, 'filterCount');
      assert.strictEqual(mapCount, 200, 'mapCount');
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('iteratee shorthands');

  (function() {
    var objects = [{ 'a': 1, 'b': 2 }, { 'a': 3, 'b': 4 }];

    QUnit.test('should work with "_.matches" shorthands', function(assert) {
      assert.expect(1);

      assert.deepEqual(fp.filter({ 'a': 3 })(objects), [objects[1]]);
    });

    QUnit.test('should work with "_.matchesProperty" shorthands', function(assert) {
      assert.expect(1);

      assert.deepEqual(fp.filter(['a', 3])(objects), [objects[1]]);
    });

    QUnit.test('should work with "_.property" shorthands', function(assert) {
      assert.expect(1);

      assert.deepEqual(fp.map('a')(objects), [1, 3]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('placeholder methods');

  (function() {
    QUnit.test('should use `fp` as the default placeholder', function(assert) {
      assert.expect(3);

      var actual = fp.add(fp, 'b')('a');
      assert.strictEqual(actual, 'ab');

      actual = fp.fill(fp, 2)(1, '*')([1, 2, 3]);
      assert.deepEqual(actual, [1, '*', 3]);

      actual = fp.slice(fp, 2)(1)(['a', 'b', 'c']);
      assert.deepEqual(actual, ['b']);
    });

    QUnit.test('should support `fp.placeholder`', function(assert) {
      assert.expect(6);

      _.each([[], fp.__], function(ph) {
        fp.placeholder = ph;

        var actual = fp.add(ph, 'b')('a');
        assert.strictEqual(actual, 'ab');

        actual = fp.fill(ph, 2)(1, '*')([1, 2, 3]);
        assert.deepEqual(actual, [1, '*', 3]);

        actual = fp.slice(ph, 2)(1)(['a', 'b', 'c']);
        assert.deepEqual(actual, ['b']);
      });
    });

    var methodNames = [
      'bind',
      'bindKey',
      'curry',
      'curryRight',
      'partial',
      'partialRight'
    ];

    _.each(methodNames, function(methodName) {
      var func = fp[methodName];

      QUnit.test('fp.' + methodName + '` should have a `placeholder` property', function(assert) {
        assert.expect(2);

        assert.ok(_.isObject(func.placeholder));
        assert.strictEqual(func.placeholder, fp.__);
      });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('setter methods');

  (function() {
    QUnit.test('should only clone objects in `path`', function(assert) {
      assert.expect(11);

      var object = { 'a': { 'b': 2, 'c': 3 }, 'd': { 'e': 4 } },
          value = _.cloneDeep(object),
          actual = fp.set('a.b.c.d', 5, value);

      assert.ok(_.isObject(actual.a.b), 'fp.set');
      assert.ok(_.isNumber(actual.a.b), 'fp.set');

      assert.strictEqual(actual.a.b.c.d, 5, 'fp.set');
      assert.strictEqual(actual.d, value.d, 'fp.set');

      value = _.cloneDeep(object);
      actual = fp.setWith(Object)('[0][1]')('a')(value);

      assert.deepEqual(actual[0], { '1': 'a' }, 'fp.setWith');

      value = _.cloneDeep(object);
      actual = fp.unset('a.b')(value);

      assert.notOk('b' in actual.a, 'fp.unset');
      assert.strictEqual(actual.a.c, value.a.c, 'fp.unset');

      value = _.cloneDeep(object);
      actual = fp.update('a.b')(square)(value);

      assert.strictEqual(actual.a.b, 4, 'fp.update');
      assert.strictEqual(actual.d, value.d, 'fp.update');

      value = _.cloneDeep(object);
      actual = fp.updateWith(Object)('[0][1]')(_.constant('a'))(value);

      assert.deepEqual(actual[0], { '1': 'a' }, 'fp.updateWith');
      assert.strictEqual(actual.d, value.d, 'fp.updateWith');
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.add and fp.subtract');

  _.each(['add', 'subtract'], function(methodName) {
    var func = fp[methodName],
        isAdd = methodName == 'add';

    QUnit.test('`fp.' + methodName + '` should not have `rearg` applied', function(assert) {
      assert.expect(1);

      assert.strictEqual(func('1')('2'), isAdd ? '12' : -1);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('object assignments');

  _.each(['assign', 'assignIn', 'defaults', 'defaultsDeep', 'merge'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('`fp.' + methodName + '` should not mutate values', function(assert) {
      assert.expect(2);

      var object = { 'a': 1 },
          actual = func(object)({ 'b': 2 });

      assert.deepEqual(object, { 'a': 1 });
      assert.deepEqual(actual, { 'a': 1, 'b': 2 });
    });
  });

  _.each(['assignAll', 'assignInAll', 'defaultsAll', 'defaultsDeepAll', 'mergeAll'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('`fp.' + methodName + '` should not mutate values', function(assert) {
      assert.expect(2);

      var objects = [{ 'a': 1 }, { 'b': 2 }],
          actual = func(objects);

      assert.deepEqual(objects[0], { 'a': 1 });
      assert.deepEqual(actual, { 'a': 1, 'b': 2 });
    });
  });

  _.each(['assignWith', 'assignInWith', 'extendWith'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('`fp.' + methodName + '` should provide the correct `customizer` arguments', function(assert) {
      assert.expect(1);

      var args;

      func(function() {
        args || (args = _.map(arguments, _.cloneDeep));
      })({ 'a': 1 })({ 'b': 2 });

      assert.deepEqual(args, [undefined, 2, 'b', { 'a': 1 }, { 'b': 2 }]);
    });
  });

  _.each(['assignAllWith', 'assignInAllWith', 'extendAllWith', 'mergeAllWith'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('`fp.' + methodName + '` should not mutate values', function(assert) {
      assert.expect(2);

      var objects = [{ 'a': 1 }, { 'b': 2 }],
          actual = func(_.noop)(objects);

      assert.deepEqual(objects[0], { 'a': 1 });
      assert.deepEqual(actual, { 'a': 1, 'b': 2 });
    });

    QUnit.test('`fp.' + methodName + '` should work with more than two sources', function(assert) {
      assert.expect(2);

      var pass = false,
          objects = [{ 'a': 1 }, { 'b': 2 }, { 'c': 3 }],
          actual = func(function() { pass = true; })(objects);

      assert.ok(pass);
      assert.deepEqual(actual, { 'a': 1, 'b': 2, 'c': 3 });
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.castArray');

  (function() {
    QUnit.test('should shallow clone array values', function(assert) {
      assert.expect(2);

      var array = [1],
          actual = fp.castArray(array);

      assert.deepEqual(actual, array);
      assert.notStrictEqual(actual, array);
    });

    QUnit.test('should not shallow clone non-array values', function(assert) {
      assert.expect(2);

      var object = { 'a': 1 },
          actual = fp.castArray(object);

      assert.deepEqual(actual, [object]);
      assert.strictEqual(actual[0], object);
    });

    QUnit.test('should convert by name', function(assert) {
      assert.expect(4);

      var array = [1],
          object = { 'a': 1 },
          castArray = convert('castArray', _.castArray),
          actual = castArray(array);

      assert.deepEqual(actual, array);
      assert.notStrictEqual(actual, array);

      actual = castArray(object);
      assert.deepEqual(actual, [object]);
      assert.strictEqual(actual[0], object);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('curry methods');

  _.each(['curry', 'curryRight'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('fp.' + methodName + '` should only accept a `func` param', function(assert) {
      assert.expect(1);

      assert.raises(function() { func(1, _.noop); }, TypeError);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('curryN methods');

  _.each(['curryN', 'curryRightN'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('fp.' + methodName + '` should accept an `arity` param', function(assert) {
      assert.expect(1);

      var actual = func(1)(function(a, b) { return [a, b]; })('a');
      assert.deepEqual(actual, ['a', undefined]);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.defaultTo');

  (function() {
    QUnit.test('should have an argument order of `defaultValue` then `value`', function(assert) {
      assert.expect(2);

      assert.strictEqual(fp.defaultTo(1)(0), 0);
      assert.strictEqual(fp.defaultTo(1)(undefined), 1);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.difference');

  (function() {
    QUnit.test('should return the elements of the first array not included in the second array', function(assert) {
      assert.expect(1);

      var actual = fp.difference([2, 1], [2, 3]);
      assert.deepEqual(actual, [1]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.differenceBy');

  (function() {
    QUnit.test('should have an argument order of `iteratee`, `array`, then `values`', function(assert) {
      assert.expect(1);

      var actual = fp.differenceBy(Math.floor, [2.1, 1.2], [2.3, 3.4]);
      assert.deepEqual(actual, [1.2]);
    });

    QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
      assert.expect(1);

      var args;

      fp.differenceBy(function() {
        args || (args = slice.call(arguments));
      })([2.1, 1.2], [2.3, 3.4]);

      assert.deepEqual(args, [2.3]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.differenceWith');

  (function() {
    QUnit.test('should have an argument order of `comparator`, `array`, then `values`', function(assert) {
      assert.expect(1);

      var actual = fp.differenceWith(fp.eq)([2, 1])([2, 3]);
      assert.deepEqual(actual, [1]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.divide and fp.multiply');

  _.each(['divide', 'multiply'], function(methodName) {
    var func = fp[methodName],
        isDivide = methodName == 'divide';

    QUnit.test('`fp.' + methodName + '` should not have `rearg` applied', function(assert) {
      assert.expect(1);

      assert.strictEqual(func('2')('4'), isDivide ? 0.5 : 8);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.extend');

  (function() {
    QUnit.test('should convert by name', function(assert) {
      assert.expect(2);

      function Foo() {}
      Foo.prototype = { 'b': 2 };

      var object = { 'a': 1 },
          extend = convert('extend', _.extend),
          actual = extend(object)(new Foo);

      assert.deepEqual(object, { 'a': 1 });
      assert.deepEqual(actual, { 'a': 1, 'b': 2 });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.fill');

  (function() {
    QUnit.test('should have an argument order of `start`, `end`, then `value`', function(assert) {
      assert.expect(1);

      var array = [1, 2, 3];
      assert.deepEqual(fp.fill(1)(2)('*')(array), [1, '*', 3]);
    });

    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var array = [1, 2, 3],
          actual = fp.fill(1)(2)('*')(array);

      assert.deepEqual(array, [1, 2, 3]);
      assert.deepEqual(actual, [1, '*', 3]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.findFrom methods');

  _.each(['findFrom', 'findIndexFrom', 'findLastFrom', 'findLastIndexFrom'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('fp.' + methodName + '` should provide the correct `predicate` arguments', function(assert) {
      assert.expect(1);

      var args;

      func(function() {
        args || (args = slice.call(arguments));
      })(1)([1, 2, 3]);

      assert.deepEqual(args, [2]);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.findFrom');

  (function() {
    function resolve(value) {
      return fp.flow(fp.property('a'), fp.eq(value));
    }

    QUnit.test('should have an argument order of `value`, `fromIndex`, then `array`', function(assert) {
      assert.expect(2);

      var objects = [{ 'a': 1 }, { 'a': 2 }, { 'a': 1 }, { 'a': 2 }];

      assert.strictEqual(fp.findFrom(resolve(1))(1)(objects), objects[2]);
      assert.strictEqual(fp.findFrom(resolve(2))(-2)(objects), objects[3]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.findLastFrom');

  (function() {
    function resolve(value) {
      return fp.flow(fp.property('a'), fp.eq(value));
    }

    QUnit.test('should have an argument order of `value`, `fromIndex`, then `array`', function(assert) {
      assert.expect(2);

      var objects = [{ 'a': 1 }, { 'a': 2 }, { 'a': 1 }, { 'a': 2 }];

      assert.strictEqual(fp.findLastFrom(resolve(1))(1)(objects), objects[0]);
      assert.strictEqual(fp.findLastFrom(resolve(2))(-2)(objects), objects[1]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.findIndexFrom and fp.indexOfFrom');

  _.each(['findIndexFrom', 'indexOfFrom'], function(methodName) {
    var func = fp[methodName],
        resolve = methodName == 'findIndexFrom' ? fp.eq : _.identity;

    QUnit.test('fp.' + methodName + '` should have an argument order of `value`, `fromIndex`, then `array`', function(assert) {
      assert.expect(2);

      var array = [1, 2, 3, 1, 2, 3];

      assert.strictEqual(func(resolve(1))(2)(array), 3);
      assert.strictEqual(func(resolve(2))(-3)(array), 4);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.findLastIndexFrom and fp.lastIndexOfFrom');

  _.each(['findLastIndexFrom', 'lastIndexOfFrom'], function(methodName) {
    var func = fp[methodName],
        resolve = methodName == 'findLastIndexFrom' ? fp.eq : _.identity;

    QUnit.test('fp.' + methodName + '` should have an argument order of `value`, `fromIndex`, then `array`', function(assert) {
      assert.expect(2);

      var array = [1, 2, 3, 1, 2, 3];

      assert.strictEqual(func(resolve(2))(3)(array), 1);
      assert.strictEqual(func(resolve(3))(-3)(array), 2);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.flatMapDepth');

  (function() {
    QUnit.test('should have an argument order of `iteratee`, `depth`, then `collection`', function(assert) {
      assert.expect(2);

      function duplicate(n) {
        return [[[n, n]]];
      }

      var array = [1, 2],
          object = { 'a': 1, 'b': 2 },
          expected = [[1, 1], [2, 2]];

      assert.deepEqual(fp.flatMapDepth(duplicate)(2)(array), expected);
      assert.deepEqual(fp.flatMapDepth(duplicate)(2)(object), expected);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('flow methods');

  _.each(['flow', 'flowRight'], function(methodName) {
    var func = fp[methodName],
        isFlow = methodName == 'flow';

    QUnit.test('`fp.' + methodName + '` should support shortcut fusion', function(assert) {
      assert.expect(6);

      var filterCount,
          mapCount,
          array = fp.range(0, LARGE_ARRAY_SIZE);

      var iteratee = function(value) {
        mapCount++;
        return square(value);
      };

      var predicate = function(value) {
        filterCount++;
        return isEven(value);
      };

      var filter = fp.filter(predicate),
          map = fp.map(iteratee),
          take = fp.take(2);

      _.times(2, function(index) {
        var combined = isFlow
          ? func(map, filter, fp.compact, take)
          : func(take, fp.compact, filter, map);

        filterCount = mapCount = 0;

        if (WeakMap && WeakMap.name) {
          assert.deepEqual(combined(array), [4, 16]);
          assert.strictEqual(filterCount, 5, 'filterCount');
          assert.strictEqual(mapCount, 5, 'mapCount');
        }
        else {
          skipAssert(assert, 3);
        }
      });
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('forEach methods');

  _.each(['forEach', 'forEachRight', 'forIn', 'forInRight', 'forOwn', 'forOwnRight'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('`fp.' + methodName + '` should provide `value` to `iteratee`', function(assert) {
      assert.expect(2);

      var args;

      func(function() {
        args || (args = slice.call(arguments));
      })(['a']);

      assert.deepEqual(args, ['a']);

      args = undefined;

      func(function() {
        args || (args = slice.call(arguments));
      })({ 'a': 1 });

      assert.deepEqual(args, [1]);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.getOr');

  (function() {
    QUnit.test('should accept a `defaultValue` param', function(assert) {
      assert.expect(1);

      var actual = fp.getOr('default')('path')({});
      assert.strictEqual(actual, 'default');
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.gt and fp.gte');

  _.each(['gt', 'gte'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('`fp.' + methodName + '` should have `rearg` applied', function(assert) {
      assert.expect(1);

      assert.strictEqual(func(2)(1), true);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.inRange');

  (function() {
    QUnit.test('should have an argument order of `start`, `end`, then `value`', function(assert) {
      assert.expect(2);

      assert.strictEqual(fp.inRange(2)(4)(3), true);
      assert.strictEqual(fp.inRange(-2)(-6)(-3), true);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.intersectionBy');

  (function() {
    QUnit.test('should have an argument order of `iteratee`, `array`, then `values`', function(assert) {
      assert.expect(1);

      var actual = fp.intersectionBy(Math.floor, [2.1, 1.2], [2.3, 3.4]);
      assert.deepEqual(actual, [2.1]);
    });

    QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
      assert.expect(1);

      var args;

      fp.intersectionBy(function() {
        args || (args = slice.call(arguments));
      })([2.1, 1.2], [2.3, 3.4]);

      assert.deepEqual(args, [2.3]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.intersectionWith');

  (function() {
    QUnit.test('should have an argument order of `comparator`, `array`, then `values`', function(assert) {
      assert.expect(1);

      var actual = fp.intersectionWith(fp.eq)([2, 1])([2, 3]);
      assert.deepEqual(actual, [2]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.invoke');

  (function() {
    QUnit.test('should not accept an `args` param', function(assert) {
      assert.expect(1);

      var actual = fp.invoke('toUpperCase')('a');
      assert.strictEqual(actual, 'A');
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.invokeMap');

  (function() {
    QUnit.test('should not accept an `args` param', function(assert) {
      assert.expect(1);

      var actual = fp.invokeMap('toUpperCase')(['a', 'b']);
      assert.deepEqual(actual, ['A', 'B']);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.invokeArgs');

  (function() {
    QUnit.test('should accept an `args` param', function(assert) {
      assert.expect(1);

      var actual = fp.invokeArgs('concat')(['b', 'c'])('a');
      assert.strictEqual(actual, 'abc');
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.invokeArgsMap');

  (function() {
    QUnit.test('should accept an `args` param', function(assert) {
      assert.expect(1);

      var actual = fp.invokeArgsMap('concat')(['b', 'c'])(['a', 'A']);
      assert.deepEqual(actual, ['abc', 'Abc']);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.isEqualWith');

  (function() {
    QUnit.test('should provide the correct `customizer` arguments', function(assert) {
      assert.expect(1);

      var args,
          iteration = 0,
          objects = [{ 'a': 1 }, { 'a': 2 }],
          stack = { '__data__': { '__data__': [objects, objects.slice().reverse()], 'size': 2 }, 'size': 2 },
          expected = [1, 2, 'a', objects[0], objects[1], stack];

      fp.isEqualWith(function() {
        if (++iteration == 2) {
          args = _.map(arguments, _.cloneDeep);
        }
      })(objects[0])(objects[1]);

      args[5] = _.omitBy(args[5], _.isFunction);
      args[5].__data__ = _.omitBy(args[5].__data__, _.isFunction);

      assert.deepEqual(args, expected);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.isMatchWith');

  (function() {
    QUnit.test('should provide the correct `customizer` arguments', function(assert) {
      assert.expect(1);

      var args,
          objects = [{ 'a': 1 }, { 'a': 2 }],
          stack = { '__data__': { '__data__': [], 'size': 0 }, 'size': 0 },
          expected = [2, 1, 'a', objects[1], objects[0], stack];

      fp.isMatchWith(function() {
        args || (args = _.map(arguments, _.cloneDeep));
      })(objects[0])(objects[1]);

      args[5] = _.omitBy(args[5], _.isFunction);
      args[5].__data__ = _.omitBy(args[5].__data__, _.isFunction);

      assert.deepEqual(args, expected);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.iteratee');

  (function() {
    QUnit.test('should return a iteratee with capped params', function(assert) {
      assert.expect(1);

      var func = fp.iteratee(function(a, b, c) { return [a, b, c]; }, 3);
      assert.deepEqual(func(1, 2, 3), [1, undefined, undefined]);
    });

    QUnit.test('should convert by name', function(assert) {
      assert.expect(1);

      var iteratee = convert('iteratee', _.iteratee),
          func = iteratee(function(a, b, c) { return [a, b, c]; }, 3);

      assert.deepEqual(func(1, 2, 3), [1, undefined, undefined]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.lt and fp.lte');

  _.each(['lt', 'lte'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('`fp.' + methodName + '` should have `rearg` applied', function(assert) {
      assert.expect(1);

      assert.strictEqual(func(1)(2), true);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.mapKeys');

  (function() {
    QUnit.test('should only provide `key` to `iteratee`', function(assert) {
      assert.expect(1);

      var args;

      fp.mapKeys(function() {
        args || (args = slice.call(arguments));
      }, { 'a': 1 });

      assert.deepEqual(args, ['a']);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.maxBy and fp.minBy');

  _.each(['maxBy', 'minBy'], function(methodName) {
    var array = [1, 2, 3],
        func = fp[methodName],
        isMax = methodName == 'maxBy';

    QUnit.test('`fp.' + methodName + '` should work with an `iteratee` argument', function(assert) {
      assert.expect(1);

      var actual = func(function(num) {
        return -num;
      })(array);

      assert.strictEqual(actual, isMax ? 1 : 3);
    });

    QUnit.test('`fp.' + methodName + '` should provide the correct `iteratee` arguments', function(assert) {
      assert.expect(1);

      var args;

      func(function() {
        args || (args = slice.call(arguments));
      })(array);

      assert.deepEqual(args, [1]);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.mergeWith');

  (function() {
    QUnit.test('should provide the correct `customizer` arguments', function(assert) {
      assert.expect(1);

      var args,
          stack = { '__data__': { '__data__': [], 'size': 0 }, 'size': 0 },
          expected = [[1, 2], [3], 'a', { 'a': [1, 2] }, { 'a': [3] }, stack];

      fp.mergeWith(function() {
        args || (args = _.map(arguments, _.cloneDeep));
      })({ 'a': [1, 2] })({ 'a': [3] });

      args[5] = _.omitBy(args[5], _.isFunction);
      args[5].__data__ = _.omitBy(args[5].__data__, _.isFunction);

      assert.deepEqual(args, expected);
    });

    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var objects = [{ 'a': [1, 2] }, { 'a': [3] }],
          actual = fp.mergeWith(_.noop, objects[0], objects[1]);

      assert.deepEqual(objects[0], { 'a': [1, 2] });
      assert.deepEqual(actual, { 'a': [3, 2] });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.mergeAllWith');

  (function() {
    QUnit.test('should provide the correct `customizer` arguments', function(assert) {
      assert.expect(1);

      var args,
          objects = [{ 'a': [1, 2] }, { 'a': [3] }],
          stack = { '__data__': { '__data__': [], 'size': 0 }, 'size': 0 },
          expected = [[1, 2], [3], 'a', { 'a': [1, 2] }, { 'a': [3] }, stack];

      fp.mergeAllWith(function() {
        args || (args = _.map(arguments, _.cloneDeep));
      })(objects);

      args[5] = _.omitBy(args[5], _.isFunction);
      args[5].__data__ = _.omitBy(args[5].__data__, _.isFunction);

      assert.deepEqual(args, expected);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.mixin');

  (function() {
    var source = { 'a': _.noop };

    QUnit.test('should mixin static methods but not prototype methods', function(assert) {
      assert.expect(2);

      fp.mixin(source);

      assert.strictEqual(typeof fp.a, 'function');
      assert.notOk('a' in fp.prototype);

      delete fp.a;
      delete fp.prototype.a;
    });

    QUnit.test('should not assign inherited `source` methods', function(assert) {
      assert.expect(2);

      function Foo() {}
      Foo.prototype.a = _.noop;
      fp.mixin(new Foo);

      assert.notOk('a' in fp);
      assert.notOk('a' in fp.prototype);

      delete fp.a;
      delete fp.prototype.a;
    });

    QUnit.test('should not remove existing prototype methods', function(assert) {
      assert.expect(2);

      var each1 = fp.each,
          each2 = fp.prototype.each;

      fp.mixin({ 'each': source.a });

      assert.strictEqual(fp.each, source.a);
      assert.strictEqual(fp.prototype.each, each2);

      fp.each = each1;
      fp.prototype.each = each2;
    });

    QUnit.test('should not export to the global when `source` is not an object', function(assert) {
      assert.expect(2);

      var props = _.without(_.keys(_), '_');

      _.times(2, function(index) {
        fp.mixin.apply(fp, index ? [1] : []);

        assert.ok(_.every(props, function(key) {
          return root[key] !== fp[key];
        }));

        _.each(props, function(key) {
          if (root[key] === fp[key]) {
            delete root[key];
          }
        });
      });
    });

    QUnit.test('should convert by name', function(assert) {
      assert.expect(3);

      var object = { 'mixin': convert('mixin', _.mixin) };

      function Foo() {}
      Foo.mixin = object.mixin;
      Foo.mixin(source);

      assert.ok('a' in Foo);
      assert.notOk('a' in Foo.prototype);

      object.mixin(source);
      assert.ok('a' in object);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.nthArg');

  (function() {
    QUnit.test('should return a curried function', function(assert) {
      assert.expect(2);

      var func = fp.nthArg(1);
      assert.strictEqual(func(1)(2), 2);

      func = fp.nthArg(-1);
      assert.strictEqual(func(1), 1);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.over');

  (function() {
    QUnit.test('should not cap iteratee args', function(assert) {
      assert.expect(2);

      _.each([fp.over, convert('over', _.over)], function(func) {
        var over = func([Math.max, Math.min]);
        assert.deepEqual(over(1, 2, 3, 4), [4, 1]);
      });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.omitBy and fp.pickBy');

  _.each(['omitBy', 'pickBy'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('`fp.' + methodName + '` should provide `value` and `key` to `iteratee`', function(assert) {
      assert.expect(1);

      var args;

      func(function() {
        args || (args = slice.call(arguments));
      })({ 'a': 1 });

      assert.deepEqual(args, [1, 'a']);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('padChars methods');

  _.each(['padChars', 'padCharsStart', 'padCharsEnd'], function(methodName) {
    var func = fp[methodName],
        isPad = methodName == 'padChars',
        isStart = methodName == 'padCharsStart';

    QUnit.test('fp.' + methodName + '` should truncate pad characters to fit the pad length', function(assert) {
      assert.expect(1);

      if (isPad) {
        assert.strictEqual(func('_-')(8)('abc'), '_-abc_-_');
      } else {
        assert.strictEqual(func('_-')(6)('abc'), isStart ? '_-_abc' : 'abc_-_');
      }
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('partial methods');

  _.each(['partial', 'partialRight'], function(methodName) {
    var func = fp[methodName],
        isPartial = methodName == 'partial';

    QUnit.test('fp.' + methodName + '` should accept an `args` param', function(assert) {
      assert.expect(1);

      var expected = isPartial ? [1, 2, 3] : [0, 1, 2];

      var actual = func(function(a, b, c) {
        return [a, b, c];
      })([1, 2])(isPartial ? 3 : 0);

      assert.deepEqual(actual, expected);
    });

    QUnit.test('fp.' + methodName + '` should convert by name', function(assert) {
      assert.expect(2);

      var expected = isPartial ? [1, 2, 3] : [0, 1, 2],
          par = convert(methodName, _[methodName]),
          ph = par.placeholder;

      var actual = par(function(a, b, c) {
        return [a, b, c];
      })([1, 2])(isPartial ? 3 : 0);

      assert.deepEqual(actual, expected);

      actual = par(function(a, b, c) {
        return [a, b, c];
      })([ph, 2])(isPartial ? 1 : 0, isPartial ? 3 : 1);

      assert.deepEqual(actual, expected);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.propertyOf');

  (function() {
    QUnit.test('should be curried', function(assert) {
      assert.expect(2);

      var object = { 'a': 1 };

      assert.strictEqual(fp.propertyOf(object, 'a'), 1);
      assert.strictEqual(fp.propertyOf(object)('a'), 1);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.pull');

  (function() {
    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var array = [1, 2, 3],
          actual = fp.pull(2)(array);

      assert.deepEqual(array, [1, 2, 3]);
      assert.deepEqual(actual, [1, 3]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.pullAll');

  (function() {
    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var array = [1, 2, 3],
          actual = fp.pullAll([1, 3])(array);

      assert.deepEqual(array, [1, 2, 3]);
      assert.deepEqual(actual, [2]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.pullAt');

  (function() {
    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var array = [1, 2, 3],
          actual = fp.pullAt([0, 2])(array);

      assert.deepEqual(array, [1, 2, 3]);
      assert.deepEqual(actual, [2]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.random');

  (function() {
    var array = Array(1000);

    QUnit.test('should support a `min` and `max` argument', function(assert) {
      assert.expect(1);

      var min = 5,
          max = 10;

      assert.ok(_.some(array, function() {
        var result = fp.random(min)(max);
        return result >= min && result <= max;
      }));
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('range methods');

  _.each(['range', 'rangeRight'], function(methodName) {
    var func = fp[methodName],
        isRange = methodName == 'range';

    QUnit.test('fp.' + methodName + '` should have an argument order of `start` then `end`', function(assert) {
      assert.expect(1);

      assert.deepEqual(func(1)(4), isRange ? [1, 2, 3] : [3, 2, 1]);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('rangeStep methods');

  _.each(['rangeStep', 'rangeStepRight'], function(methodName) {
    var func = fp[methodName],
        isRange = methodName == 'rangeStep';

    QUnit.test('fp.' + methodName + '` should have an argument order of `step`, `start`, then `end`', function(assert) {
      assert.expect(1);

      assert.deepEqual(func(2)(1)(4), isRange ? [1, 3] : [3, 1]);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.rearg');

  (function() {
    function fn(a, b, c) {
      return [a, b, c];
    }

    QUnit.test('should be curried', function(assert) {
      assert.expect(1);

      var rearged = fp.rearg([1, 2, 0])(fn);
      assert.deepEqual(rearged('c', 'a', 'b'), ['a', 'b', 'c']);
    });

    QUnit.test('should return a curried function', function(assert) {
      assert.expect(1);

      var rearged = fp.rearg([1, 2, 0], fn);
      assert.deepEqual(rearged('c')('a')('b'), ['a', 'b', 'c']);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('reduce methods');

  _.each(['reduce', 'reduceRight'], function(methodName) {
    var func = fp[methodName],
        isReduce = methodName == 'reduce';

    QUnit.test('`fp.' + methodName + '` should provide the correct `iteratee` arguments when iterating an array', function(assert) {
      assert.expect(1);

      var args;

      func(function() {
        args || (args = slice.call(arguments));
      })(0)([1, 2, 3]);

      assert.deepEqual(args, isReduce ? [0, 1] : [3, 0]);
    });

    QUnit.test('`fp.' + methodName + '` should provide the correct `iteratee` arguments when iterating an object', function(assert) {
      assert.expect(1);

      var args,
          object = { 'a': 1, 'b': 2 },
          isFIFO = _.keys(object)[0] == 'a';

      var expected = isFIFO
        ? (isReduce ? [0, 1] : [2, 0])
        : (isReduce ? [0, 2] : [1, 0]);

      func(function() {
        args || (args = slice.call(arguments));
      })(0)(object);

      assert.deepEqual(args, expected);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.remove');

  (function() {
    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var array = [1, 2, 3],
          actual = fp.remove(fp.eq(2))(array);

      assert.deepEqual(array, [1, 2, 3]);
      assert.deepEqual(actual, [1, 3]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.restFrom');

  (function() {
    QUnit.test('should accept a `start` param', function(assert) {
      assert.expect(1);

      var actual = fp.restFrom(2)(function() {
        return slice.call(arguments);
      })('a', 'b', 'c', 'd');

      assert.deepEqual(actual, ['a', 'b', ['c', 'd']]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.reverse');

  (function() {
    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var array = [1, 2, 3],
          actual = fp.reverse(array);

      assert.deepEqual(array, [1, 2, 3]);
      assert.deepEqual(actual, [3, 2, 1]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.runInContext');

  (function() {
    QUnit.test('should return a converted lodash instance', function(assert) {
      assert.expect(1);

      assert.strictEqual(typeof fp.runInContext({}).curryN, 'function');
    });

    QUnit.test('should convert by name', function(assert) {
      assert.expect(1);

      var runInContext = convert('runInContext', _.runInContext);
      assert.strictEqual(typeof runInContext({}).curryN, 'function');
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.set');

  (function() {
    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var object = { 'a': { 'b': 2, 'c': 3 } },
          actual = fp.set('a.b')(3)(object);

      assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } });
      assert.deepEqual(actual, { 'a': { 'b': 3, 'c': 3 } });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.setWith');

  (function() {
    QUnit.test('should provide the correct `customizer` arguments', function(assert) {
      assert.expect(1);

      var args;

      fp.setWith(function() {
        args || (args = _.map(arguments, _.cloneDeep));
      })('b.c')(2)({ 'a': 1 });

      assert.deepEqual(args, [undefined, 'b', { 'a': 1 }]);
    });

    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var object = { 'a': { 'b': 2, 'c': 3 } },
          actual = fp.setWith(Object)('d.e')(4)(object);

      assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } });
      assert.deepEqual(actual, { 'a': { 'b': 2, 'c': 3 }, 'd': { 'e': 4 } });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.spreadFrom');

  (function() {
    QUnit.test('should accept a `start` param', function(assert) {
      assert.expect(1);

      var actual = fp.spreadFrom(2)(function() {
        return slice.call(arguments);
      })('a', 'b', ['c', 'd']);

      assert.deepEqual(actual, ['a', 'b', 'c', 'd']);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('trimChars methods');

  _.each(['trimChars', 'trimCharsStart', 'trimCharsEnd'], function(methodName, index) {
    var func = fp[methodName],
        parts = [];

    if (index != 2) {
      parts.push('leading');
    }
    if (index != 1) {
      parts.push('trailing');
    }
    parts = parts.join(' and ');

    QUnit.test('`fp.' + methodName + '` should remove ' + parts + ' `chars`', function(assert) {
      assert.expect(1);

      var string = '-_-a-b-c-_-',
          expected = (index == 2 ? '-_-' : '') + 'a-b-c' + (index == 1 ? '-_-' : '');

      assert.strictEqual(func('_-')(string), expected);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.unionBy');

  (function() {
    QUnit.test('should have an argument order of `iteratee`, `array`, then `other`', function(assert) {
      assert.expect(1);

      var actual = fp.unionBy(Math.floor, [2.1], [1.2, 2.3]);
      assert.deepEqual(actual, [2.1, 1.2]);
    });

    QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
      assert.expect(1);

      var args;

      fp.unionBy(function() {
        args || (args = slice.call(arguments));
      })([2.1], [1.2, 2.3]);

      assert.deepEqual(args, [2.1]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.unionWith');

  (function() {
    QUnit.test('should have an argument order of `comparator`, `array`, then `values`', function(assert) {
      assert.expect(1);

      var actual = fp.unionWith(fp.eq)([2, 1])([2, 3]);
      assert.deepEqual(actual, [2, 1, 3]);
    });

    QUnit.test('should provide the correct `comparator` arguments', function(assert) {
      assert.expect(1);

      var args;

      fp.unionWith(function() {
        args || (args = slice.call(arguments));
      })([2, 1])([2, 3]);

      assert.deepEqual(args, [1, 2]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.uniqBy');

  (function() {
    var objects = [{ 'a': 2 }, { 'a': 3 }, { 'a': 1 }, { 'a': 2 }, { 'a': 3 }, { 'a': 1 }];

    QUnit.test('should work with an `iteratee` argument', function(assert) {
      assert.expect(1);

      var expected = objects.slice(0, 3),
          actual = fp.uniqBy(_.property('a'))(objects);

      assert.deepEqual(actual, expected);
    });

    QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
      assert.expect(1);

      var args;

      fp.uniqBy(function() {
        args || (args = slice.call(arguments));
      })(objects);

      assert.deepEqual(args, [objects[0]]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.uniqWith');

  (function() {
    QUnit.test('should have an argument order of `comparator`, `array`, then `values`', function(assert) {
      assert.expect(1);

      var actual = fp.uniqWith(fp.eq)([2, 1, 2]);
      assert.deepEqual(actual, [2, 1]);
    });

    QUnit.test('should provide the correct `comparator` arguments', function(assert) {
      assert.expect(1);

      var args;

      fp.uniqWith(function() {
        args || (args = slice.call(arguments));
      })([2, 1, 2]);

      assert.deepEqual(args, [1, 2]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.update');

  (function() {
    QUnit.test('should not convert end of `path` to an object', function(assert) {
      assert.expect(1);

      var actual = fp.update('a.b')(_.identity)({ 'a': { 'b': 1 } });
      assert.strictEqual(typeof actual.a.b, 'number');
    });

    QUnit.test('should not convert uncloneables to objects', function(assert) {
      assert.expect(2);

      var object = { 'a': { 'b': _.constant(true) } },
          actual = fp.update('a.b')(_.identity)(object);

      assert.strictEqual(typeof object.a.b, 'function');
      assert.strictEqual(object.a.b, actual.a.b);
    });

    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var object = { 'a': { 'b': 2, 'c': 3 } },
          actual = fp.update('a.b')(square)(object);

      assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } });
      assert.deepEqual(actual, { 'a': { 'b': 4, 'c': 3 } });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.updateWith');

  (function() {
    QUnit.test('should provide the correct `customizer` arguments', function(assert) {
      var args;

      fp.updateWith(function() {
        args || (args = _.map(arguments, _.cloneDeep));
      })('b.c')(_.constant(2))({ 'a': 1 });

      assert.deepEqual(args, [undefined, 'b', { 'a': 1 }]);
    });

    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var object = { 'a': { 'b': 2, 'c': 3 } },
          actual = fp.updateWith(Object)('d.e')(_.constant(4))(object);

      assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } });
      assert.deepEqual(actual, { 'a': { 'b': 2, 'c': 3 }, 'd': { 'e': 4 } });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.unset');

  (function() {
    QUnit.test('should not mutate values', function(assert) {
      assert.expect(2);

      var object = { 'a': { 'b': 2, 'c': 3 } },
          actual = fp.unset('a.b')(object);

      assert.deepEqual(object, { 'a': { 'b': 2, 'c': 3 } });
      assert.deepEqual(actual, { 'a': { 'c': 3 } });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.xorBy');

  (function() {
    QUnit.test('should have an argument order of `iteratee`, `array`, then `other`', function(assert) {
      assert.expect(1);

      var actual = fp.xorBy(Math.floor, [2.1, 1.2], [2.3, 3.4]);
      assert.deepEqual(actual, [1.2, 3.4]);
    });

    QUnit.test('should provide the correct `iteratee` arguments', function(assert) {
      assert.expect(1);

      var args;

      fp.xorBy(function() {
        args || (args = slice.call(arguments));
      })([2.1, 1.2], [2.3, 3.4]);

      assert.deepEqual(args, [2.3]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.xorWith');

  (function() {
    QUnit.test('should have an argument order of `comparator`, `array`, then `values`', function(assert) {
      assert.expect(1);

      var actual = fp.xorWith(fp.eq)([2, 1])([2, 3]);
      assert.deepEqual(actual, [1, 3]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('with methods');

  _.each(['differenceWith', 'intersectionWith', 'xorWith'], function(methodName) {
    var func = fp[methodName];

    QUnit.test('`fp.' + methodName + '` should provide the correct `comparator` arguments', function(assert) {
      assert.expect(1);

      var args;

      func(function() {
        args || (args = slice.call(arguments));
      })([2, 1])([2, 3]);

      assert.deepEqual(args, [2, 2]);
    });
  });

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.zip');

  (function() {
    QUnit.test('should zip together two arrays', function(assert) {
      assert.expect(1);

      assert.deepEqual(fp.zip([1, 2])([3, 4]), [[1, 3], [2, 4]]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.zipAll');

  (function() {
    QUnit.test('should zip together an array of arrays', function(assert) {
      assert.expect(1);

      assert.deepEqual(fp.zipAll([[1, 2], [3, 4], [5, 6]]), [[1, 3, 5], [2, 4, 6]]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.zipObject');

  (function() {
    QUnit.test('should zip together key/value arrays into an object', function(assert) {
      assert.expect(1);

      assert.deepEqual(fp.zipObject(['a', 'b'])([1, 2]), { 'a': 1, 'b': 2 });
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.module('fp.zipWith');

  (function() {
    QUnit.test('should zip arrays combining grouped elements with `iteratee`', function(assert) {
      assert.expect(1);

      var array1 = [1, 2, 3],
          array2 = [4, 5, 6],
          actual = fp.zipWith(add)(array1)(array2);

      assert.deepEqual(actual, [5, 7, 9]);
    });
  }());

  /*--------------------------------------------------------------------------*/

  QUnit.config.asyncRetries = 10;
  QUnit.config.hidepassed = true;

  if (!document) {
    QUnit.config.noglobals = true;
    QUnit.load();
    QUnit.start();
  }
}.call(this));

# Advanced Patterns

```{currentmodule} click
```

In addition to common functionality, Click offers some advanced features.

```{contents}
:depth: 1
:local: true
```

## Callbacks and Eager Options

Sometimes, you want a parameter to completely change the execution flow.
For instance, this is the case when you want to have a `--version`
parameter that prints out the version and then exits the application.

Note: an actual implementation of a `--version` parameter that is
reusable is available in Click as {func}`click.version_option`. The code
here is merely an example of how to implement such a flag.

In such cases, you need two concepts: eager parameters and a callback. An
eager parameter is a parameter handled before others, and a
callback is what executes after the parameter is handled. The eagerness
is necessary so that an earlier required parameter does not produce an
error message. For instance, if `--version` was not eager and a
parameter `--foo` was required and defined before, you would need to
specify it for `--version` to work. For more information, see
{ref}`callback-evaluation-order`.

A callback is a function invoked with three parameters: the
current {class}`Context`, the current {class}`Parameter`, and the value.
The context provides some useful features such as quitting the
application and gives access to other already processed parameters.

Here's an example for a `--version` flag:

```{eval-rst}
.. click:example::

    def print_version(ctx, param, value):
        if not value or ctx.resilient_parsing:
            return
        click.echo('Version 1.0')
        ctx.exit()

    @click.command()
    @click.option('--version', is_flag=True, callback=print_version,
                  expose_value=False, is_eager=True)
    def hello():
        click.echo('Hello World!')


What it looks like:


.. click:run::

    invoke(hello)
    invoke(hello, args=['--version'])
```
The `expose_value` parameter prevents the pretty pointless `version`
parameter from being passed to the callback. If that was not specified, a
boolean would be passed to the `hello` script. The `resilient_parsing`
flag is applied to the context if Click wants to parse the command line
without any destructive behavior that would change the execution flow. In
this case, because we would exit the program, we instead do nothing.

## Callbacks for Validation

```{versionchanged} 2.0
```

If you want to apply custom validation logic, you can do this in the
parameter callbacks. These callbacks can both modify values and
raise errors if the validation does not work. The callback runs after
type conversion. It is called for all sources, including prompts.

In Click 1.0, you can only raise the {exc}`UsageError` but starting with
Click 2.0, you can also raise the {exc}`BadParameter` error, which has the
added advantage that it will automatically format the error message to
also contain the parameter name.

```{eval-rst}
.. click:example::

    def validate_rolls(ctx, param, value):
        if isinstance(value, tuple):
            return value

        try:
            rolls, _, dice = value.partition("d")
            return int(dice), int(rolls)
        except ValueError:
            raise click.BadParameter("format must be 'NdM'")

    @click.command()
    @click.option(
        "--rolls", type=click.UNPROCESSED, callback=validate_rolls,
        default="1d6", prompt=True,
    )
    def roll(rolls):
        sides, times = rolls
        click.echo(f"Rolling a {sides}-sided dice {times} time(s)")

.. click:run::

    invoke(roll, args=["--rolls=42"])
    println()
    invoke(roll, args=["--rolls=2d12"])
    println()
    invoke(roll, input=["42", "2d12"])
```

## Parameter Modifications

Parameters (options and arguments) are forwarded to the command callbacks,
as you have seen. One common way to prevent a parameter from being passed
to the callback is the `expose_value` argument to a parameter which hides
the parameter entirely. The way this works is that the {class}`Context`
object has a {attr}`~Context.params` attribute which is a dictionary of
all parameters. Whatever is in that dictionary is being passed to the
callbacks.

This can be used to make up additional parameters. Generally, this pattern
is not recommended, but in some cases it can be useful. At the very least,
it's good to know that the system works this way.

```{eval-rst}
.. click:example::

    import urllib.request

    def open_url(ctx, param, value):
        if value is not None:
            ctx.params['fp'] = urllib.request.urlopen(value)
            return value

    @click.command()
    @click.option('--url', callback=open_url)
    def cli(url, fp=None):
        if fp is not None:
            click.echo(f"{url}: {fp.code}")

In this case the callback returns the URL unchanged but also passes a
second `fp` value to the callback.

.. caution::

   Writing to :attr:`~click.Context.params` directly bypasses Click's
   per-parameter pipeline: :meth:`~click.Context.get_parameter_source` returns
   ``None`` for it, the value is never run through any :class:`~click.ParamType`
   conversion. And if the key collides with a declared parameter, then the
   shared-name arbitration loses information about where the value came from.
   Prefer the wrapper pattern below when any of those semantics matter.

What's more recommended is to pass the information in a wrapper, however:

.. click:example::

    import urllib.request

    class URL:
        def __init__(self, url, fp):
            self.url = url
            self.fp = fp

    def open_url(ctx, param, value):
        if value is not None:
            return URL(value, urllib.request.urlopen(value))

    @click.command()
    @click.option('--url', callback=open_url)
    def cli(url):
        if url is not None:
            click.echo(f"{url.url}: {url.fp.code}")

```

## Token Normalization

```{versionadded} 2.0
```

Starting with Click 2.0, it's possible to provide a function used
for normalizing tokens. Tokens are option names, choice values, or command
values. This can be used to implement case-insensitive options, for
instance.

To use this feature, the context needs to be passed a function that
performs the normalization of the token. Such as a function that converts the
token to lowercase:

```{eval-rst}
.. click:example::

    CONTEXT_SETTINGS = {'token_normalize_func': lambda x: x.lower()}

    @click.command(context_settings=CONTEXT_SETTINGS)
    @click.option('--name', default='Pete')
    def cli(name):
        click.echo(f"Name: {name}")

# And how it works on the command line:

.. click:run::

    invoke(cli, prog_name='cli', args=['--NAME=Pete'])
```

## Invoking Other Commands

Sometimes, it might be interesting to invoke one command from another
command. This is a pattern generally discouraged with Click, but
possible nonetheless. For this, you can use the {func}`Context.invoke`
or {func}`Context.forward` methods.

They work similarly, but the difference is that {func}`Context.invoke` merely
invokes another command with the arguments you provide as a caller,
whereas {func}`Context.forward` fills in the arguments from the current
command. Both accept the command as the first argument, and everything else
is passed onwards as you would expect.

Example:

```{eval-rst}
.. click:example::

    cli = click.Group()

    @cli.command()
    @click.option('--count', default=1)
    def test(count):
        click.echo(f'Count: {count}')

    @cli.command()
    @click.option('--count', default=1)
    @click.pass_context
    def dist(ctx, count):
        ctx.forward(test)
        ctx.invoke(test, count=42)

And what it looks like:

.. click:run::

    invoke(cli, prog_name='cli', args=['dist'])
```

(forwarding-unknown-options)=

## Forwarding Unknown Options

In some situations, it is interesting to be able to accept all unknown
options for further manual processing. Click can generally do that as of
Click 4.0, but it has some limitations that lie in the nature of the
problem. The support for this is provided through a parser flag called
`ignore_unknown_options` which will instruct the parser to collect all
unknown options and to put them to the leftover argument instead of
triggering a parsing error.

This can generally be activated in two different ways:

1. It can be enabled on custom {class}`Command` subclasses by changing
   the {attr}`~Command.ignore_unknown_options` attribute.
2. It can be enabled by changing the attribute of the same name on the
   context class ({attr}`Context.ignore_unknown_options`). This is best
   changed through the `context_settings` dictionary on the command.

For most situations, the easiest solution is the second. Once the behavior
is changed, something needs to pick up those leftover options (which at
this point are considered arguments). For this again, you have two
options:

1. You can use {func}`pass_context` to get the context passed. This will
   only work if in addition to {attr}`~Context.ignore_unknown_options`
   you also set {attr}`~Context.allow_extra_args` as otherwise the
   command will abort with an error that there are leftover arguments.
   If you go with this solution, the extra arguments will be collected in
   {attr}`Context.args`.
2. You can attach an {func}`argument` with `nargs` set to `-1` which
   will eat up all leftover arguments. In this case it's recommended to
   set the `type` to {data}`UNPROCESSED` to avoid any string processing
   on those arguments as otherwise they are forced into Unicode strings
   automatically which is often not what you want.

In the end, the result looks something like this:

```{eval-rst}
.. click:example::

    from subprocess import call

    @click.command(context_settings={'ignore_unknown_options': True})
    @click.option('-v', '--verbose', is_flag=True, help='Enables verbose mode')
    @click.argument('timeit_args', nargs=-1, type=click.UNPROCESSED)
    def cli(verbose, timeit_args):
        """A fake wrapper around Python's timeit."""
        cmdline = ['echo', 'python', '-mtimeit', *timeit_args]
        if verbose:
            click.echo(f"Invoking: {' '.join(cmdline)}")
        call(cmdline)


And the final output resembles the following:

.. click:run::

    invoke(cli, prog_name='cli', args=['--help'])
    println()
    invoke(cli, prog_name='cli', args=['-n', '100', 'a = 1; b = 2; a * b'])
    println()
    invoke(cli, prog_name='cli', args=['-v', 'a = 1; b = 2; a * b'])
```

As you can see, Click handles the verbosity flag and everything else
ends up in the `timeit_args` variable for further processing, which then
for instance, allows invoking a subprocess. There are a few things that
are important to know about how this ignoring of unhandled flag happens:

- Unknown long options are generally ignored and not processed at all.
  So for instance if `--foo=bar` or `--foo bar` are passed they
  generally end up like that. Note that because the parser cannot know
  if an option will accept an argument or not, the `bar` part might be
  handled as an argument.
- Unknown short options might be partially handled and reassembled if
  necessary. For instance in the above example there is an option
  called `-v` which enables verbose mode. If the command would be
  invoked with `-va` then the `-v` part would be handled by Click
  (as it is known) and `-a` would end up in the leftover parameters
  for further processing.
- Depending on what you plan on doing you might have some success by
  disabling interspersed arguments
  ({attr}`~Context.allow_interspersed_args`) which instructs the parser
  to not allow arguments and options to be mixed. Depending on your
   situation, this might improve your results.

Generally, combining the handling of options and arguments from your own
commands with those from another application is discouraged, and you
should avoid it if possible. It's a much better idea to have
everything below a subcommand be forwarded to another application than to
handle some arguments yourself.

## Managing Resources

It can be useful to open a resource in a group, to be made available to
subcommands. Many types of resources need to be closed or otherwise
cleaned up after use. The standard way to do this in Python is by using
a context manager with the `with` statement.

For example, the `Repo` class from {doc}`complex` might actually be
defined as a context manager:

```python
class Repo:
    def __init__(self, home=None):
        self.home = os.path.abspath(home or ".")
        self.db = None

    def __enter__(self):
        path = os.path.join(self.home, "repo.db")
        self.db = open_database(path)
        return self

    def __exit__(self, exc_type, exc_value, tb):
        self.db.close()
```

Ordinarily, it would be used with the `with` statement:

```python
with Repo() as repo:
    repo.db.query(...)
```

However, a `with` block in a group would exit and close the database
before it could be used by a subcommand.

Instead, use the context's {meth}`~click.Context.with_resource` method
to enter the context manager and return the resource. When the group and
any subcommands finish, the context's resources are cleaned up.

```python
@click.group()
@click.option("--repo-home", default=".repo")
@click.pass_context
def cli(ctx, repo_home):
    ctx.obj = ctx.with_resource(Repo(repo_home))

@cli.command()
@click.pass_obj
def log(obj):
    # obj is the repo opened in the cli group
    for entry in obj.db.query(...):
        click.echo(entry)
```

If the resource isn't a context manager, usually it can be wrapped in
one using something from {mod}`contextlib`. If that's not possible, use
the context's {meth}`~click.Context.call_on_close` method to register a
cleanup function.

```python
@click.group()
@click.option("--name", default="repo.db")
@click.pass_context
def cli(ctx, name):
    ctx.obj = db = open_db(name)

    @ctx.call_on_close
    def close_db():
        db.record_use()
        db.save()
        db.close()
```

```{versionchanged} 8.2
`Context.call_on_close` and context managers registered via `Context.with_resource`
will be closed when the CLI exits. These were previously not called on exit.
```

Aksjomat indukcji – aksjomat, a właściwie nieskończony przeliczalny zbiór aksjomatów pierwszego rzędu, pozalogicznych rozważany zwłaszcza w teorii arytmetyki liczb naturalnych. Jest on formalizacją zasady indukcji matematycznej.

Jego treść przedstawia się następująco:
 

gdzie  oznacza: „dla każdego n” ⇒, to wynikanie (implikacja)  oznacza „i”. Tak wyrażony aksjomat indukcji nie spełnia jednak założeń rozlicznych podejść, a w tym np. analizy Gödla niesprzeczności teorii matematycznych w szczególności arytmetyki. Problemem jest zupełna nieobliczalność relacji użytych do konstrukcji powyższego zdania: kwantyfikator ogólny „dla każdego n” nie da się bowiem zapisać jako funkcja obliczalna. Ponadto zdanie powyższe jest zdaniem drugiego rzędu z uwagi na użycie kwantyfikatora, co sprawia, że operuje ono obiektami niezdefiniowanymi w teorii (zbiorem liczb naturalnych n, z którego mamy wybierać wartości: nie można go skonstruować, zanim nie ustalimy listy aksjomatów i nie udowodnimy ich niesprzeczności).

Równoważnie aksjomat indukcji można zapisać jako koniunkcję zbioru aksjomatów w następującej postaci:
 

w której to notacji nie został użyty nieograniczony, a więc nieobliczalny (nierekurencyjny) kwantyfikator ogólny, wszystkie zdania są zaś pierwszego rzędu (wyrażają prawdy o zdefiniowanych wcześniej pojęciach pierwotnych arytmetyki, nie używając kwantyfikatora ogólnego). Uzyskujemy w ten sposób formalną poprawność sformułowania aksjomatu.

Aksjomaty indukcji są ważnym elementem teorii arytmetyki.

Znane są przykłady twierdzeń, w których chociaż znamy dowody twierdzenia  dla każdego  to twierdzenie  nie może być dowiedzione w ramach arytmetyki liczb naturalnych (jest niedowiedlne), gdyż każdy z tych dowodów jest prowadzony za pomocą innych narzędzi i nie da się ich sprowadzić do kroku indukcyjnego (a więc rozumowania wykazującego ), zapisanego za pomocą języka arytmetyki i obejmującego wszystkie możliwe wartości  (dla każdego n pojawia się pewien nowy element niewystępujący dla innych ).

Zobacz też 
 aksjomat nieskończoności
 indukcja matematyczna

Bibliografia 
 Roman Murawski, Funkcje rekurencyjne i elementy metamatematyki. Problemy zupełności, rozstrzygalności, twierdzenia Gödla, Wydawnictwo Naukowe UAM, Poznań 1990.

Logika matematyczna

Annamocarya es un género monotípico de árboles de la familia Juglandaceae. Su única especie, Annamocarya sinensis es nativa del sudoeste de China (Guangxi, Guizhou, Yunnan) y norte de Vietnam. Se relaciona con Carya, y estaba incluida en el mismo género homónimo, como Carya sinensis, pero compartía ciertos  caracteres con Juglans.

Descripción 
Es un árbol de medio a grande, siempreverde de hasta 30 m de altura. Las hojas son de 3 a 5 dm de longitud, pinnadas con 7 a 11 folíolos que tienen márgenes enteros, distinguiéndose de Carya por tener bordes aserrados. Las flores tienen amentos producidos en primavera, con los amentos masculino en manojos de 5 a 8 juntos (simples en Carya). El fruto es una nuez de 6 a 8 cm de long. y 4 a 6 cm de ancho, con un prominente pico agudo en un extremo.

Taxonomía 
El género fue descrito por Auguste Jean Baptiste Chevalier y publicado en Revue de Botanique Appliquée et d'Agriculture Tropicale, 21, p. 504 en el año 1941.

Sinonimia 
 Annamocarya indochinensis (A.Chev.) A. Chev.
 Carya integrifoliolata (Kuang) Hjelmq.
 Carya sinensis Dode
 Carya tsiangiana Chun ex Lee
 Carya tsiangii Chun ex Kuang & A.M.Lu
 Juglandicarya integrifoliolata (Kuang) Hu
 Juglans indochinensis A. Chev.
 Rhamphocarya integrifoliolata Kuang

Referencias

Bibliografía 
 Flora of China Editorial Committee, 1999. Fl. China Vol. 4.

Enlaces externos 
 Annamocarya en eFlora''

Juglandaceae
Flora de China
Flora de Indochina
Flora de Asia continental

Aikido ( ,  , , ) is a modern Japanese martial art that is split into many different styles, including Iwama Ryu, Iwama Shin Shin Aiki Shuren Kai, Shodokan Aikido, Yoshinkan, Renshinkai, Aikikai and Ki Aikido. Aikido is now practiced in around 140 countries. It was originally developed by Morihei Ueshiba, as a synthesis of his martial studies, philosophy and religious beliefs. Ueshiba's goal was to create an art that practitioners could use to defend themselves while also protecting their attackers from injury. Aikido is often translated as "the way of unifying (with) life energy" or as "the way of harmonious spirit". According to the founder's philosophy, the primary goal in the practice of aikido is to overcome oneself instead of cultivating violence or aggressiveness. Morihei Ueshiba used the phrase  to refer to this principle.

Aikido's fundamental principles include:  (entering), ,  (breathing control),  (triangular principle) and  (turning) movements that redirect the opponent's attack momentum. Its curriculum comprises various techniques, primarily throws and joint locks. It also includes a weapons system encompassing the ,  and .

Aikido derives mainly from the martial art of Daitō-ryū Aiki-jūjutsu, but began to diverge from it in the late 1920s, partly due to Ueshiba's involvement with the Ōmoto-kyō religion. Ueshiba's early students' documents bear the term .

Ueshiba's senior students have different approaches to aikido, depending partly on when they studied with him. Today, aikido is found all over the world in a number of styles, with broad ranges of interpretation and emphasis. However, they all share techniques formulated by Ueshiba and most have concern for the well-being of the attacker.

Etymology and basic philosophy

The word "aikido" is formed of three kanji:
  –  – harmony, unifying
  –  – energy, spirit
  –  – way, path

The term  does not readily appear in the Japanese language outside the scope of budō. This has led to many possible interpretations of the word.

 () is mainly used in compounds to mean 'combine, unite, join together, meet', examples being  (combined/united),  (composition),  (unite/combine/join together),  (union/alliance/association),  (combine/unify), and  (mutual agreement). There is an idea of reciprocity,  (to get to know one another),  (talk/discussion/negotiation), and  (meet by appointment).

 () is often used to describe a feeling or emotive action, as in  ('I feel X', as in terms of thinking but with less cognitive reasoning), and  (feeling/sensation); it is used to mean energy or force, as in  (electricity) and  (magnetism); it can also refer to qualities or aspects of people or things, as in  (spirit/trait/temperament). The characters aeteological history can be traced back to the much older Chinese character of  () that is used extensively in Traditional Chinese medicine and acupunture.

The term  in Aikido is found in many other Japanese martial arts such as, judo and kendo, and in various non-martial arts, such as Japanese calligraphy (), flower arranging () and tea ceremony ( or ).

Therefore, from a purely literal interpretation, aikido is the "Way of combining forces" or "Way of unifying energy", in which the term  refers to the martial arts principle or tactic of blending with an attacker's movements for the purpose of controlling their actions with minimal effort. One applies  by understanding the rhythm and intent of the attacker to find the optimal position and timing to apply a counter-technique.

History

Aikido was created by  (1883–1969), referred to by some aikido practitioners as  (Great Teacher). The term aikido was coined in the 20th century. Ueshiba envisioned aikido not only as the synthesis of his martial training, but as an expression of his personal philosophy of universal peace and reconciliation. During Ueshiba's lifetime and continuing today, aikido has evolved from the  that Ueshiba studied into a variety of expressions by martial artists throughout the world.

Initial development

Ueshiba developed aikido primarily during the late 1920s through the 1930s through the synthesis of the older martial arts that he had studied. The core martial art from which aikido derives is Daitō-ryū Aiki-jūjutsu, which Ueshiba studied directly with Takeda Sōkaku, the reviver of that art. Additionally, Ueshiba is known to have studied Tenjin Shin'yō-ryū with Tozawa Tokusaburō in Tokyo in 1901, Gotōha Yagyū Shingan-ryū under Nakai Masakatsu in Sakai from 1903 to 1908, and judo with  (1894–1972) in Tanabe in 1911.

The art of  is the primary technical influence on aikido. Along with empty-handed throwing and joint-locking techniques, Ueshiba incorporated training movements with weapons, such as those for the spear (), short staff (), and possibly the . Aikido also derives much of its technical structure from the art of swordsmanship ().

Ueshiba moved to Hokkaidō in 1912, and began studying under Takeda Sokaku in 1915; His official association with Daitō-ryū continued until 1937. However, during the latter part of that period, Ueshiba had already begun to distance himself from Takeda and the . At that time Ueshiba referred to his martial art as "Aiki Budō". It is unclear exactly when Ueshiba began using the name "aikido", but it became the official name of the art in 1942 when the Greater Japan Martial Virtue Society () was engaged in a government sponsored reorganization and centralization of Japanese martial arts.

Religious influences

After Ueshiba left Hokkaidō in 1919, he met and was profoundly influenced by Onisaburo Deguchi, the spiritual leader of the Ōmoto-kyō religion (a neo-Shinto movement) in Ayabe. One of the primary features of Ōmoto-kyō is its emphasis on the attainment of utopia during one's life. This idea was a great influence on Ueshiba's martial arts philosophy of extending love and compassion especially to those who seek to harm others. Aikido demonstrates this philosophy in its emphasis on mastering martial arts so that one may receive an attack and harmlessly redirect it. In an ideal resolution, not only is the receiver unharmed, but so is the attacker.

In addition to the effect on his spiritual growth, the connection with Deguchi gave Ueshiba entry to elite political and military circles as a martial artist. As a result of this exposure, he was able to attract not only financial backing but also gifted students. Several of these students would found their own styles of aikido.

International dissemination
Aikido was first introduced to the rest of the world in 1951 by Minoru Mochizuki with a visit to France, where he demonstrated aikido techniques to judo students. He was followed by Tadashi Abe in 1952, who came as the official Aikikai Hombu representative, remaining in France for seven years. Kenji Tomiki toured with a delegation of various martial arts through 15 continental states of the United States in 1953. Later that year, Koichi Tohei was sent by Aikikai Hombu to Hawaii for a full year, where he set up several dōjō. This trip was followed by several subsequent visits and is considered the formal introduction of aikido to the United States. The United Kingdom followed in 1955; Italy in 1964 by Hiroshi Tada; and Germany in 1965 by Katsuaki Asai. Designated the "Official Delegate for Europe and Africa" by Morihei Ueshiba, Masamichi Noro arrived in France in September 1961. Seiichi Sugano was appointed to introduce aikido to Australia in 1965. Today there are aikido dōjō throughout the world.

Proliferation of independent organizations

The largest aikido organization is the Aikikai Foundation, which remains under the control of the Ueshiba family. However, aikido has developed into many styles, most of which were formed by Morihei Ueshiba's major students.

The earliest independent styles to emerge were Yoseikan Aikido, begun by Minoru Mochizuki in 1931, Yoshinkan Aikido, founded by Gozo Shioda in 1955, and Shodokan Aikido, founded by Kenji Tomiki in 1967. The emergence of these styles pre-dated Ueshiba's death and did not cause any major upheavals when they were formalized. Shodokan Aikido, however, was controversial, since it introduced a unique rule-based competition that some felt was contrary to the spirit of aikido.

After Ueshiba's death in 1969, two more major styles emerged. Significant controversy arose with the departure of the Aikikai Hombu Dojo's chief instructor Koichi Tohei, in 1974. Tohei left as a result of a disagreement with the son of the founder, Kisshomaru Ueshiba, who at that time headed the Aikikai Foundation. The disagreement was over the proper role of  development in regular aikido training. After Tohei left, he formed his own style, called Shin Shin Toitsu Aikido, and the organization that governs it, the Ki Society ().

A final major style evolved from Ueshiba's retirement in Iwama, Ibaraki and the teaching methodology of long term student Morihiro Saito. It is unofficially referred to as the "Iwama style", and at one point a number of its followers formed a loose network of schools they called Iwama Ryu. Although Iwama style practitioners remained part of the Aikikai until Saito's death in 2002, followers of Saito subsequently split into two groups. One remained with the Aikikai and the other formed the independent Shinshin Aikishuren Kai in 2004 around Saito's son Hitohiro Saito.

Today, the major styles of aikido are each run by a separate governing organization, have their own  in Japan, and are taught throughout the world.

The study of  is an important component of aikido. The term does not specifically refer to either physical or mental training, as it encompasses both. The kanji for  was written in its older form as  up until the Japanese governmental writing reforms after World War II, and now is more prevalently seen in its modern form of . This form has the removal of the eight directions denoting the pre and post natal energies of  (Chinese – ) also known in the Art of Aikido as "Source energy".

The character for  is used in everyday Japanese terms, such as , or .  has many meanings, including "ambience", "mind", "mood", or "intention and action", however, in traditional martial arts and medicine it is often referred to in its more general terminology as "life energy". Gozo Shioda's Yoshinkan Aikido, considered one of the "hard styles", largely follows Ueshiba's teachings from before World War II, and surmises that the secret to  lies in timing and the application of the whole body's strength to a single point. In later years, Ueshiba's application of  in aikido took on a softer, more gentle feel. This concept was known as Takemusu Aiki, and many of his later students teach about  from this perspective. Koichi Tohei's Ki Society centers almost exclusively around the study of the empirical (albeit subjective) experience of , with students' proficiency in aikido techniques and  development ranked separately.

Training

In aikido, as in virtually all Japanese martial arts, there are both physical and mental aspects of training. The physical training in aikido is diverse, covering both general physical fitness and conditioning, as well as specific techniques. Because a substantial portion of any aikido curriculum consists of throws, beginners learn how to safely fall or roll. The specific techniques for attack include both strikes and grabs; the techniques for defense consist of throws and pins. After basic techniques are learned, students study freestyle defense against multiple opponents, and techniques with weapons.

Fitness
Physical training goals pursued in conjunction with aikido include controlled relaxation, correct movement of joints such as hips and shoulders, flexibility, and endurance, with less emphasis on strength training. In aikido, pushing or extending movements are much more common than pulling or contracting movements. This distinction can be applied to general fitness goals for the aikido practitioner.

In aikido, specific muscles or muscle groups are not isolated and worked to improve tone, mass, or power. Aikido-related training emphasizes the use of coordinated whole-body movement and balance similar to yoga or pilates. For example, many dōjōs begin each class with , which may include stretching and  (break falls).

Roles of  and 
 
Aikido training is based primarily on two partners practicing pre-arranged forms () rather than freestyle practice. The basic pattern is for the receiver of the technique () to initiate an attack against the person who applies the technique—the , or  (depending on aikido style), also referred to as  (when applying a throwing technique), who neutralises this attack with an aikido technique.

Both halves of the technique, that of  and that of , are considered essential to aikido training. Both are studying aikido principles of blending and adaptation.  learns to blend with and control attacking energy, while  learns to become calm and flexible in the disadvantageous, off-balance positions in which  places them. This "receiving" of the technique is called .  continuously seeks to regain balance and cover vulnerabilities (e.g., an exposed side), while  uses position and timing to keep  off-balance and vulnerable. In more advanced training,  will sometimes apply  to regain balance and pin or throw .

 refers to the act of receiving a technique. Good  involves attention to the technique, the partner, and the immediate environment—it is considered an active part of the process of learning aikido. The method of falling itself is also important, and is a way for the practitioner to receive an aikido technique safely and minimize risk of injury.

Initial attacks
Aikido techniques are usually a defense against an attack, so students must learn to deliver various types of attacks to be able to practice aikido with a partner. Although attacks are not studied as thoroughly as in striking-based arts, attacks with intent (such as a strong strike or an immobilizing grab) are needed to study correct and effective application of technique.

Many of the  of aikido resemble cuts from a sword or other grasped object, which indicate its origins in techniques intended for armed combat. Other techniques, which explicitly appear to be punches (), are practiced as thrusts with a knife or sword. Kicks are generally reserved for upper-level variations; reasons cited include that falls from kicks are especially dangerous, and that kicks (high kicks in particular) were uncommon during the types of combat prevalent in feudal Japan.

Some basic strikes include:
  is a vertical knifehand strike to the head. In training, this is usually directed at the forehead or the crown for safety, but more dangerous versions of this attack target the bridge of the nose and the maxillary sinus.
  is a diagonal knifehand strike to the side of the head or neck.
  is a punch to the torso. Specific targets include the chest, abdomen, and solar plexus, sometimes referred to as , or .
  is a punch to the face, sometimes referred to as .

Beginners in particular often practice techniques from grabs, both because they are safer and because it is easier to feel the energy and the direction of the movement of force of a hold than it is for a strike. Some grabs are historically derived from being held while trying to draw a weapon, whereupon a technique could then be used to free oneself and immobilize or strike the attacker while they are grabbing the defender. The following are examples of some basic grabs:
 , when one hand grabs one wrist.
 , when both hands grab one wrist; sometimes referred to as 
 , when both hands grab both wrists; sometimes referred to as .
  when one shoulder is grabbed.
 , when both shoulders are grabbed. It is sometimes combined with an overhead strike as .
 , when the lapel is grabbed; sometimes referred to as .

Basic techniques

The following are a sample of the basic or widely practiced throws and pins. Many of these techniques derive from Daitō-ryū Aiki-jūjutsu, but some others were invented by Morihei Ueshiba. The precise terminology for some may vary between organisations and styles; the following are the terms used by the Aikikai Foundation. Note that despite the names of the first five techniques listed, they are not universally taught in numeric order.
 , a control technique using one hand on the elbow and one hand near the wrist which leverages  to the ground. This grip applies pressure into the ulnar nerve at the wrist.
  is a pronating wristlock that torques the arm and applies painful nerve pressure. (There is an adductive wristlock or Z-lock in the  version.)
  is a rotational wristlock that directs upward-spiraling tension throughout the arm, elbow and shoulder.
  is a shoulder control technique similar to , but with both hands gripping the forearm. The knuckles (from the palm side) are applied to the recipient's radial nerve against the periosteum of the forearm bone.
 is a technique that is visually similar to , but with an inverted grip of the wrist, medial rotation of the arm and shoulder, and downward pressure on the elbow. Common in knife and other weapon take-aways.
  is a throw during which 's hand is folded back past the shoulder, locking the shoulder joint.
  is a supinating wristlock-throw that stretches the extensor digitorum.
  is a loosely used umbrella term for various types of mechanically unrelated techniques;  generally do not use joint locks like other techniques.
 , throws in which  moves through the space occupied by . The classic form superficially resembles a "clothesline" technique.
 , a throw in which, beginning with , moving forward,  sweeps one hand low ("earth") and the other high ("heaven"), which unbalances  so that he or she easily topples over.
 , aikido's version of the hip throw;  drops their hips lower than those of , then flips  over the resultant fulcrum.
  or , a throw that locks the arms against each other (the kanji for "10" is a cross-shape: ).
  is a throw in which  sweeps 's arm back until it locks the shoulder joint, then uses forward pressure to throw them.

Implementations

Aikido makes use of body movement () to blend the movement of  with the movement of . For example, an "entering" () technique consists of movements inward towards , while a  technique uses a pivoting motion.
Additionally, an  technique takes place in front of , whereas an  technique takes place to their side; a  technique is applied with motion to the front of , and a  version is applied with motion towards the rear of , usually by incorporating a turning or pivoting motion. Finally, most techniques can be performed while in a seated posture (). Techniques where both  and  are standing are called , techniques where both start off in  are called , and techniques performed with  standing and  sitting are called  ().

From these few basic techniques, there are numerous of possible implementations. For example,  can be applied to an opponent moving forward with a strike (perhaps with an  type of movement to redirect the incoming force), or to an opponent who has already struck and is now moving back to reestablish distance (perhaps an  version). Specific aikido  are typically referred to with the formula "attack-technique(-modifier)"; , for example, refers to any  technique executed when  is holding one wrist. This could be further specified as  (referring to any forward-moving  technique from that grab).

 are strikes (or feints) employed during an aikido technique. Some view  as attacks against "vital points" meant to cause damage in and of themselves. For instance, Gozo Shioda described using  in a brawl to quickly down a gang's leader. Others consider , especially to the face, to be methods of distraction meant to enable other techniques; a strike, even if it is blocked, can startle the target and break their concentration. Additionally, the target may also become unbalanced while attempting to avoid a strike (by jerking the head back, for example) which may allow for an easier throw. Many sayings about  are attributed to Morihei Ueshiba, who considered them an essential element of technique.

Weapons

Weapons training in aikido traditionally includes the short staff () (these techniques closely resemble the use of the bayonet, or Jūkendō), the wooden sword (), and the knife (). Some schools incorporate firearm-disarming techniques, where either weapon-taking and/or weapon-retention may be taught. Some schools, such as the Iwama style of Morihiro Saito, usually spend substantial time practicing with both  and , under the names of , and , respectively.

The founder developed many of the empty-handed techniques from traditional sword, spear and bayonet movements. Consequently, the practice of the weapons arts gives insight into the origin of techniques and movements, and reinforces the concepts of distance, timing, foot movement, presence and connectedness with one's training partner(s).

Multiple attackers and 
One feature of aikido is training to defend against multiple attackers, often called , or . Freestyle practice with multiple attackers called  is a key part of most curricula and is required for the higher-level ranks.  exercises a person's ability to intuitively perform techniques in an unstructured environment. Strategic choice of techniques, based on how they reposition the student relative to other attackers, is important in  training. For instance, an  technique might be used to neutralise the current attacker while turning to face attackers approaching from behind.

In Shodokan Aikido,  differs in that it is not performed with multiple persons with defined roles of defender and attacker, but between two people, where both participants attack, defend, and counter at will. In this respect it resembles judo .

Injuries
In applying a technique during training, it is the responsibility of  to prevent injury to  by employing a speed and force of application that is appropriate with their partner's proficiency in . When injuries (especially to the joints) occur, they are often the result of a  misjudging the ability of  to receive the throw or pin.

A study of injuries in the martial arts showed that the type of injuries varied considerably from one art to the other. Soft tissue injuries are one of the most common types of injuries found within aikido, as well as joint strain and stubbed fingers and toes. Several deaths from head-and-neck injuries, caused by aggressive  in a  hazing context, have been reported.

Mental training
Aikido training is mental as well as physical, emphasizing the ability to relax the mind and body even under the stress of dangerous situations. This is necessary to enable the practitioner to perform the 'enter-and-blend' movements that underlie aikido techniques, wherein an attack is met with confidence and directness. Morihei Ueshiba once remarked that one "must be willing to receive 99% of an opponent's attack and stare death in the face" in order to execute techniques without hesitation. As a martial art concerned not only with fighting proficiency but with the betterment of daily life, this mental aspect is of key importance to aikido practitioners.

Uniforms and ranking

Aikido practitioners (commonly called  outside Japan) generally progress by promotion through a series of "grades" (), followed by a series of "degrees" (), pursuant to formal testing procedures. Some aikido organizations use belts to distinguish practitioners' grades, often simply white and black belts to distinguish  and  grades, although some use various belt colors. Testing requirements vary, so a particular rank in one organization is not comparable or interchangeable with the rank of another. Some dōjōs have an age requirement before students can take the  rank exam.

The uniform worn for practicing aikido () is similar to the training uniform () used in most other modern martial arts; simple trousers and a wraparound jacket, usually white. Both thi

use log::{debug, error, info, trace, warn, Level, LevelFilter, Log, Metadata, Record};
use std::sync::{Arc, Mutex};

#[cfg(feature = "std")]
use log::set_boxed_logger;
#[cfg(not(feature = "std"))]
fn set_boxed_logger(logger: Box<dyn Log>) -> Result<(), log::SetLoggerError> {
    log::set_logger(Box::leak(logger))
}

struct State {
    last_log: Mutex<Option<Level>>,
}

struct Logger(Arc<State>);

impl Log for Logger {
    fn enabled(&self, _: &Metadata) -> bool {
        true
    }

    fn log(&self, record: &Record) {
        *self.0.last_log.lock().unwrap() = Some(record.level());
    }

    fn flush(&self) {}
}

fn main() {
    let me = Arc::new(State {
        last_log: Mutex::new(None),
    });
    let a = me.clone();
    set_boxed_logger(Box::new(Logger(me))).unwrap();

    test(&a, LevelFilter::Off);
    test(&a, LevelFilter::Error);
    test(&a, LevelFilter::Warn);
    test(&a, LevelFilter::Info);
    test(&a, LevelFilter::Debug);
    test(&a, LevelFilter::Trace);
}

fn test(a: &State, filter: LevelFilter) {
    log::set_max_level(filter);
    error!("");
    last(&a, t(Level::Error, filter));
    warn!("");
    last(&a, t(Level::Warn, filter));
    info!("");
    last(&a, t(Level::Info, filter));

    debug!("");
    if cfg!(debug_assertions) {
        last(&a, t(Level::Debug, filter));
    } else {
        last(&a, None);
    }

    trace!("");
    last(&a, None);

    fn t(lvl: Level, filter: LevelFilter) -> Option<Level> {
        if lvl <= filter {
            Some(lvl)
        } else {
            None
        }
    }
}

fn last(state: &State, expected: Option<Level>) {
    let mut lvl = state.last_log.lock().unwrap();
    assert_eq!(*lvl, expected);
    *lvl = None;
}

عصر آزادگان روزنامه‌ای اصلاح‌طلب بود که پس از توقیف روزنامه‌های جامعه، توس و نشاط به مدیرمسئولی غفور گرشاسبی و به سردبیری ماشاالله شمس‌الواعظین منتشر گردید. این روزنامه در ۱۵ مهر ۱۳۷۸ با تیتر یک «بازگشت آزادگان به جامعه» آغز به کار کرد و در جریان توقیف گسترده مطبوعات در اردیبهشت ۱۳۷۹ که به توقیف فله‌ای مشهور شد، پس از چند ماه انتشار توسط قوهٔ قضائیهٔ جمهوری اسلامی ایران توقیف گردید.

دبیران این روزنامه در زمان انتشار:
 اکبر گنجی، که در مورد سرویس مخفی ایران می‌نوشت.
 ابراهیم نبوی، که طنز سیاسی روزانه می‌نوشت.
 حسین درخشان، که یک ستون فناوری به‌طور منظم می‌نوشت.
 مسعود بهنود، که یک ستون نظر به‌طور منظم می‌نوشت.

منابع 

انحلال‌های ۲۰۰۰ (میلادی) در ایران
بنیان‌گذاری‌های ۱۹۹۹ (میلادی) در ایران
رسانه در تهران
روزنامه‌های اصلاح‌طلب ایران
روزنامه‌های بنیان‌گذاری‌شده در ۱۹۹۹ (میلادی)
روزنامه‌های فارسی‌زبان
روزنامه‌های منحل‌شده ایران
نشریه‌های ایران
نشریه‌های بنیان‌گذاری‌شده در ۱۹۹۹ (میلادی)
نشریه‌های توقیف‌شده
نشریه‌های منحل‌شده در ۲۰۰۰ (میلادی)

# Change Log

## [0.4.33] - 2026-06-20

## What's Changed
* Fixed key comparison by @matteo-zeggiotti-ok in https://github.com/rust-lang/log/pull/732

## New Contributors
* @matteo-zeggiotti-ok made their first contribution in https://github.com/rust-lang/log/pull/732

**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.32...0.4.33

## [0.4.32] - 2026-06-04

### What's Changed
* Support `Value` -> string conversions with `kv` + `std` features instead of `kv_std` by @tisonkun in https://github.com/rust-lang/log/pull/729

**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.31...0.4.32

## [0.4.31] - 2026-06-02

### What's Changed
* Leverage static str key when possible by @tisonkun in https://github.com/rust-lang/log/pull/727

### New Contributors
* @Isvane made their first contribution in https://github.com/rust-lang/log/pull/726

**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.30...0.4.31

## [0.4.30] - 2026-05-21

### What's Changed
* Support capturing of `std::net` types by @KodrAus in https://github.com/rust-lang/log/pull/724

### New Contributors
* @V0ldek made their first contribution in https://github.com/rust-lang/log/pull/720
* @woodruffw made their first contribution in https://github.com/rust-lang/log/pull/723

**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.29...0.4.30

### Notable Changes
* MSRV is bumped to 1.71.0 in https://github.com/rust-lang/log/pull/723

## [0.4.29] - 2025-12-02

### What's Changed
* perf: reduce llvm-lines of FromStr for `Level` and `LevelFilter` by @dishmaker in https://github.com/rust-lang/log/pull/709
* Replace serde with serde_core by @Thomasdezeeuw in https://github.com/rust-lang/log/pull/712

### New Contributors
* @AldaronLau made their first contribution in https://github.com/rust-lang/log/pull/703
* @dishmaker made their first contribution in https://github.com/rust-lang/log/pull/709

**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.28...0.4.29

## [0.4.28] - 2025-09-02

### What's Changed
* ci: drop really old trick and ensure MSRV for all feature combo by @tisonkun in https://github.com/rust-lang/log/pull/676
* Chore: delete compare_exchange method for AtomicUsize on platforms without atomics  by @HaoliangXu in https://github.com/rust-lang/log/pull/690
* Add `increment_severity()` and `decrement_severity()` methods for `Level` and `LevelFilter` by @nebkor in https://github.com/rust-lang/log/pull/692

## New Contributors
* @xixishidibei made their first contribution in https://github.com/rust-lang/log/pull/677
* @ZylosLumen made their first contribution in https://github.com/rust-lang/log/pull/688
* @HaoliangXu made their first contribution in https://github.com/rust-lang/log/pull/690
* @nebkor made their first contribution in https://github.com/rust-lang/log/pull/692

**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.27...0.4.28

### Notable Changes
* MSRV is bumped to 1.61.0 in https://github.com/rust-lang/log/pull/676

## [0.4.27] - 2025-03-24

### What's Changed
* A few minor lint fixes by @nyurik in https://github.com/rust-lang/log/pull/671
* Enable clippy support for format-like macros by @nyurik in https://github.com/rust-lang/log/pull/665
* Add an optional logger param by @tisonkun in https://github.com/rust-lang/log/pull/664
* Pass global logger by value, supplied logger by ref by @KodrAus in https://github.com/rust-lang/log/pull/673


**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.26...0.4.27


## [0.4.26] - 2025-02-18

### What's Changed
* Derive `Clone` for `kv::Value` by @SpriteOvO in https://github.com/rust-lang/log/pull/668
* Add `spdlog-rs` link to crate doc by @SpriteOvO in https://github.com/rust-lang/log/pull/669


**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.25...0.4.26

## [0.4.25] - 2025-01-14

### What's Changed
* Revert loosening of kv cargo features by @KodrAus in https://github.com/rust-lang/log/pull/662


**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.24...0.4.25

## [0.4.24] - 2025-01-11

### What's Changed
* Fix up kv feature activation by @KodrAus in https://github.com/rust-lang/log/pull/659


**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.23...0.4.24

## [0.4.23] - 2025-01-10 (yanked)

### What's Changed
* Fix some typos by @Kleinmarb in https://github.com/rust-lang/log/pull/637
* Add logforth to implementation by @tisonkun in https://github.com/rust-lang/log/pull/638
* Add `spdlog-rs` link to README by @SpriteOvO in https://github.com/rust-lang/log/pull/639
* Add correct lifetime to kv::Value::to_borrowed_str by @stevenroose in https://github.com/rust-lang/log/pull/643
* docs: Add logforth as an impl by @tisonkun in https://github.com/rust-lang/log/pull/642
* Add clang_log implementation by @DDAN-17 in https://github.com/rust-lang/log/pull/646
* Bind lifetimes of &str returned from Key by the lifetime of 'k rather than the lifetime of the Key struct by @gbbosak in https://github.com/rust-lang/log/pull/648
* Fix up key lifetimes and add method to try get a borrowed key by @KodrAus in https://github.com/rust-lang/log/pull/653
* Add Ftail implementation by @tjardoo in https://github.com/rust-lang/log/pull/652

### New Contributors
* @Kleinmarb made their first contribution in https://github.com/rust-lang/log/pull/637
* @tisonkun made their first contribution in https://github.com/rust-lang/log/pull/638
* @SpriteOvO made their first contribution in https://github.com/rust-lang/log/pull/639
* @stevenroose made their first contribution in https://github.com/rust-lang/log/pull/643
* @DDAN-17 made their first contribution in https://github.com/rust-lang/log/pull/646
* @gbbosak made their first contribution in https://github.com/rust-lang/log/pull/648
* @tjardoo made their first contribution in https://github.com/rust-lang/log/pull/652

**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.22...0.4.23

## [0.4.22] - 2024-06-27

### What's Changed
* Add some clarifications to the library docs by @KodrAus in https://github.com/rust-lang/log/pull/620
* Add links to `colog` crate by @chrivers in https://github.com/rust-lang/log/pull/621
* adding line_number test + updating some testing infrastructure by @DIvkov575 in https://github.com/rust-lang/log/pull/619
* Clarify the actual set of functions that can race in _racy variants by @KodrAus in https://github.com/rust-lang/log/pull/623
* Replace deprecated std::sync::atomic::spin_loop_hint() by @Catamantaloedis in https://github.com/rust-lang/log/pull/625
* Check usage of max_level features by @Thomasdezeeuw in https://github.com/rust-lang/log/pull/627
* Remove unneeded import by @Thomasdezeeuw in https://github.com/rust-lang/log/pull/628
* Loosen orderings for logger initialization in https://github.com/rust-lang/log/pull/632. Originally by @pwoolcoc in https://github.com/rust-lang/log/pull/599
* Use Location::caller() for file and line info in https://github.com/rust-lang/log/pull/633. Originally by @Cassy343 in https://github.com/rust-lang/log/pull/520

### New Contributors
* @chrivers made their first contribution in https://github.com/rust-lang/log/pull/621
* @DIvkov575 made their first contribution in https://github.com/rust-lang/log/pull/619
* @Catamantaloedis made their first contribution in https://github.com/rust-lang/log/pull/625

**Full Changelog**: https://github.com/rust-lang/log/compare/0.4.21...0.4.22

## [0.4.21] - 2024-02-27

### What's Changed
* Minor clippy nits by @nyurik in https://github.com/rust-lang/log/pull/578
* Simplify Display impl by @nyurik in https://github.com/rust-lang/log/pull/579
* Set all crates to 2021 edition by @nyurik in https://github.com/rust-lang/log/pull/580
* Various changes based on review by @Thomasdezeeuw in https://github.com/rust-lang/log/pull/583
* Fix typo in file_static() method doc by @dimo414 in https://github.com/rust-lang/log/pull/590
* Specialize empty key value pairs by @EFanZh in https://github.com/rust-lang/log/pull/576
* Fix incorrect lifetime in Value::to_str() by @peterjoel in https://github.com/rust-lang/log/pull/587
* Remove some API of the key-value feature by @Thomasdezeeuw in https://github.com/rust-lang/log/pull/585
* Add logcontrol-log and log-reload by @swsnr in https://github.com/rust-lang/log/pull/595
* Add Serialization section to kv::Value docs by @Thomasdezeeuw in https://github.com/rust-lang/log/pull/593
* Rename Value::to_str to to_cow_str by @Thomasdezeeuw in https://github.com/rust-lang/log/pull/592
* Clarify documentation and simplify initialization of `STATIC_MAX_LEVEL` by @ptosi in https://github.com/rust-lang/log/pull/594
* Update docs to 2021 edition, test by @nyurik in https://github.com/rust-lang/log/pull/577
* Add "alterable_logger" link to README.md by @brummer-simon in https://github.com/rust-lang/log/pull/589
* Normalize line ending by @EFanZh in https://github.com/rust-lang/log/pull/602
* Remove `ok_or` in favor of `Option::ok_or` by @AngelicosPhosphoros in https://github.com/rust-lang/log/pull/607
* Use `Acquire` ordering for initialization check by @AngelicosPhosphoros in https://github.com/rust-lang/log/pull/610
* Get structured logging API ready for stabilization by @KodrAus in https://github.com/rust-lang/log/pull/613

### New Contributors
* @nyurik made their first contribution in https://github.com/rust-lang/log/pull/578
* @dimo414 made their first contribution in https://github.com/rust-lang/log/pull/590
* @peterjoel made their first contribution in https://github.com/rust-lang/log/pull/587
* @ptosi made their first contribution in https://github.com/rust-lang/log/pull/594
* @brummer-simon made their first contribution in https://github.com/rust-lang/log/pull/589
* @AngelicosPhosphoros made their first contribution in https://github.com/rust-lang/log/pull/607

## [0.4.20] - 2023-07-11

* Remove rustversion dev-dependency by @Thomasdezeeuw in https://github.com/rust-lang/log/pull/568
* Remove `local_inner_macros` usage by @EFanZh in https://github.com/rust-lang/log/pull/570

## [0.4.19] - 2023-06-10

* Use target_has_atomic instead of the old atomic_cas cfg by @GuillaumeGomez in https://github.com/rust-lang/log/pull/555
* Put MSRV into Cargo.toml by @est31 in https://github.com/rust-lang/log/pull/557

## [0.4.18] - 2023-05-28

* fix Markdown links (again) by @hellow554 in https://github.com/rust-lang/log/pull/513
* add cargo doc to workflow by @hellow554 in https://github.com/rust-lang/log/pull/515
* Apply Clippy lints by @hellow554 in https://github.com/rust-lang/log/pull/516
* Replace ad-hoc eq_ignore_ascii_case with slice::eq_ignore_ascii_case by @glandium in https://github.com/rust-lang/log/pull/519
* fix up windows targets by @KodrAus in https://github.com/rust-lang/log/pull/528
* typo fix by @jiangying000 in https://github.com/rust-lang/log/pull/529
* Remove dependency on cfg_if by @EriKWDev in https://github.com/rust-lang/log/pull/536
* GitHub Workflows security hardening by @sashashura in https://github.com/rust-lang/log/pull/538
* Fix build status badge by @atouchet in https://github.com/rust-lang/log/pull/539
* Add call_logger to the documentation by @a1ecbr0wn in https://github.com/rust-lang/log/pull/547
* Use stable internals for key-value API by @KodrAus in https://github.com/rust-lang/log/pull/550
* Change wording of list of implementations by @Thomasdezeeuw in https://github.com/rust-lang/log/pull/553
* Add std-logger to list of implementations by @Thomasdezeeuw in https://github.com/rust-lang/log/pull/554
* Add `set_max_level_racy` and gate `set_max_level` by @djkoloski in https://github.com/rust-lang/log/pull/544
* [doc] src/lib.rs : prefix an unused variable with an underscore by @OccupyMars2025 in https://github.com/rust-lang/log/pull/561
* [doc] src/macros.rs :  correct  grammar errors of an example in lib documentation by @OccupyMars2025 in https://github.com/rust-lang/log/pull/562

## [0.4.17] - 2022-04-29

* Update `kv_unstable` internal dependencies.

## [0.4.16] - 2022-03-22

* Fix a conflict with unqualified `Option` use in macros.

## [0.4.15] - 2022-02-23

* Silence a warning about the deprecated `spin_loop_hint`.
* Relax ordering in the atomic `set_max_level` call.
* Add thumbv4t-none-eabi to targets that don't support atomics
* Allow levels to be iterated over.
* Implement `Log` on some common wrapper types.
* Improvements to test coverage.
* Improvements to documentation.
* Add key-value support to the `log!` macros.
* Tighten `kv_unstable` internal dependencies, so they don't bump past their current alpha.
* Add a simple visit API to `kv_unstable`.
* Support `NonZero*` integers as values in structured logging
* Support static strings as keys in structured logging

## [0.4.14] - 2021-01-27

* Remove the `__private_api_log_lit` special case.
* Fixed incorrect combination of `kv_unstable` and `std` features causing compile failures.
* Remove unstable `Value::to_*` conversions that were incorrectly using `as`.
* Rename unstable `Value::to_error` to `Value::to_borrowed_error`.

## [0.4.13] - 2021-01-11

* This is the same as `0.4.11`, except with a `kv_unstable_std` feature added to aid migrating current dependents to `0.4.14` (which was originally going to be `0.4.13` until it was decided to create a patch from `0.4.11` to minimize disruption).

## [0.4.12] - 2020-12-24

### New

* Support platforms without atomics by racing instead of failing to compile
* Implement `Log` for `Box<T: Log>`
* Update `cfg-if` to `1.0`
* Internal reworks of the structured logging API. Removed the `Fill` API
and added `source::as_map` and `source::as_list` to easily serialize a `Source`
as either a map of `{key: value, ..}` or as a list of `[(key, value), ..]`.

### Fixed

* Fixed deserialization of `LevelFilter` to use their `u64` index variants

## [0.4.11] - 2020-07-09

### New

* Support coercing structured values into concrete types.
* Reference the `win_dbg_logger` in the readme.

### Fixed

* Updates a few deprecated items used internally.
* Fixed issues in docs and expands sections.
* Show the correct build badge in the readme.
* Fix up a possible inference breakage with structured value errors.
* Respect formatting flags in structured value formatting.

## [0.4.10] - 2019-12-16 (yanked)

### Fixed

* Fixed the `log!` macros, so they work in expression context (this regressed in `0.4.9`, which has been yanked).

## [0.4.9] - 2019-12-12 (yanked)

### Minimum Supported Rust Version

This release bumps the minimum compiler version to `1.31.0`. This was mainly needed for `cfg-if`,
but between `1.16.0` and `1.31.0` there are a lot of language and library improvements we now
take advantage of.

### New

* Unstable support for capturing key-value pairs in a record using the `log!` macros

### Improved

* Better documentation for max level filters.
* Internal updates to line up with bumped MSRV

## [0.4.8] - 2019-07-28

### New

* Support attempting to get `Record` fields as static strings.

## [0.4.7] - 2019-07-06

### New

* Support for embedded environments with thread-unsafe initialization.
* Initial unstable support for capturing structured data under the `kv_unstable`
feature gate. This new API doesn't affect existing users and may change in future
patches (so those changes may not appear in the changelog until it stabilizes).

### Improved

* Docs for using `log` with the 2018 edition.
* Error messages for macros missing arguments.

## [0.4.6] - 2018-10-27

### Improved

* Support 2018-style macro import for the `log_enabled!` macro.

## [0.4.5] - 2018-09-03

### Improved

* Make `log`'s internal helper macros less likely to conflict with user-defined
  macros.

## [0.4.4] - 2018-08-17

### Improved

* Support 2018-style imports of the log macros.

## [0.4.3] - 2018-06-29

### Improved

* More code generation improvements.

## [0.4.2] - 2018-06-05

### Improved

* Log invocations now generate less code.

### Fixed

* Example Logger implementations now properly set the max log level.

## [0.4.1] - 2017-12-30

### Fixed

* Some doc links were fixed.

## [0.4.0] - 2017-12-24

The changes in this release include cleanup of some obscure functionality and a more robust public
API designed to support bridges to other logging systems, and provide more flexibility to new
features in the future.

### Compatibility

Vast portions of the Rust ecosystem use the 0.3.x release series of log, and we don't want to force
the community to go through the pain of upgrading every crate to 0.4.x at the exact same time. Along
with 0.4.0, we've published a new 0.3.9 release which acts as a "shim" over 0.4.0. This will allow
crates using either version to coexist without losing messages from one side or the other.

There is one caveat - a log message generated by a crate using 0.4.x but consumed by a logging
implementation using 0.3.x will not have a file name or module path. Applications affected by this
can upgrade their logging implementations to one using 0.4.x to avoid losing this information. The
other direction does not lose any information, fortunately!

**TL;DR** Libraries should feel comfortable upgrading to 0.4.0 without treating that as a breaking
change. Applications may need to update their logging implementation (e.g. env-logger) to a newer
version using log 0.4.x to avoid losing module and file information.

### New

* The crate is now `no_std` by default.
* `Level` and `LevelFilter` now implement `Serialize` and `Deserialize` when the `serde` feature is
    enabled.
* The `Record` and `Metadata` types can now be constructed by third-party code via a builder API.
* The `logger` free function returns a reference to the logger implementation. This, along with the
    ability to construct `Record`s, makes it possible to bridge from another logging framework to
    this one without digging into the private internals of the crate. The standard `error!` `warn!`,
    etc., macros now exclusively use the public API of the crate rather than "secret" internal APIs.
* `Log::flush` has been added to allow crates to tell the logging implementation to ensure that all
    "in flight" log events have been persisted. This can be used, for example, just before an
    application exits to ensure that asynchronous log sinks finish their work.

### Removed

* The `shutdown` and `shutdown_raw` functions have been removed. Supporting shutdown significantly
    complicated the implementation and imposed a performance cost on each logging operation.
* The `log_panics` function and its associated `nightly` Cargo feature have been removed. Use the
    [log-panics](https://crates.io/crates/log-panics) instead.

### Changed

* The `Log` prefix has been removed from type names. For example, `LogLevelFilter` is now
    `LevelFilter`, and `LogRecord` is now `Record`.
* The `MaxLogLevelFilter` object has been removed in favor of a `set_max_level` free function.
* The `set_logger` free functions have been restructured. The logger is now directly passed to the
    functions rather than a closure which returns the logger. `set_logger` now takes a `&'static
    Log` and is usable in `no_std` contexts in place of the old `set_logger_raw`. `set_boxed_logger`
    is a convenience function which takes a `Box<Log>` but otherwise acts like `set_logger`. It
    requires the `std` feature.
* The `file` and `module_path` values in `Record` no longer have the `'static` lifetime to support
    integration with other logging frameworks that don't provide a `'static` lifetime for the
    equivalent values.
* The `file`, `line`, and `module_path` values in `Record` are now `Option`s to support integration
    with other logging frameworks that don't provide those values.

### In the Future

* We're looking to add support for *structured* logging - the inclusion of extra key-value pairs of
    information in a log event in addition to the normal string message. This should be able to be
    added in a backwards compatible manner to the 0.4.x series when the design is worked out.

## Older

Look at the [release tags] for information about older releases.

[Unreleased]: https://github.com/rust-lang-nursery/log/compare/0.4.33...HEAD
[0.4.32]: https://github.com/rust-lang/log/compare/0.4.32...0.4.33
[0.4.32]: https://github.com/rust-lang/log/compare/0.4.31...0.4.32
[0.4.31]: https://github.com/rust-lang/log/compare/0.4.30...0.4.31
[0.4.30]: https://github.com/rust-lang/log/compare/0.4.29...0.4.30
[0.4.29]: https://github.com/rust-lang/log/compare/0.4.28...0.4.29
[0.4.28]: https://github.com/rust-lang/log/compare/0.4.27...0.4.28
[0.4.27]: https://github.com/rust-lang/log/compare/0.4.26...0.4.27
[0.4.26]: https://github.com/rust-lang/log/compare/0.4.25...0.4.26
[0.4.25]: https://github.com/rust-lang/log/compare/0.4.24...0.4.25
[0.4.24]: https://github.com/rust-lang/log/compare/0.4.23...0.4.24
[0.4.23]: https://github.com/rust-lang/log/compare/0.4.22...0.4.23
[0.4.22]: https://github.com/rust-lang/log/compare/0.4.21...0.4.22
[0.4.21]: https://github.com/rust-lang/log/compare/0.4.20...0.4.21
[0.4.20]: https://github.com/rust-lang-nursery/log/compare/0.4.19...0.4.20
[0.4.19]: https://github.com/rust-lang-nursery/log/compare/0.4.18...0.4.19
[0.4.18]: https://github.com/rust-lang-nursery/log/compare/0.4.17...0.4.18
[0.4.17]: https://github.com/rust-lang-nursery/log/compare/0.4.16...0.4.17
[0.4.16]: https://github.com/rust-lang-nursery/log/compare/0.4.15...0.4.16
[0.4.15]: https://github.com/rust-lang-nursery/log/compare/0.4.13...0.4.15
[0.4.14]: https://github.com/rust-lang-nursery/log/compare/0.4.13...0.4.14
[0.4.13]: https://github.com/rust-lang-nursery/log/compare/0.4.11...0.4.13
[0.4.12]: https://github.com/rust-lang-nursery/log/compare/0.4.11...0.4.12
[0.4.11]: https://github.com/rust-lang-nursery/log/compare/0.4.10...0.4.11
[0.4.10]: https://github.com/rust-lang-nursery/log/compare/0.4.9...0.4.10
[0.4.9]: https://github.com/rust-lang-nursery/log/compare/0.4.8...0.4.9
[0.4.8]: https://github.com/rust-lang-nursery/log/compare/0.4.7...0.4.8
[0.4.7]: https://github.com/rust-lang-nursery/log/compare/0.4.6...0.4.7
[0.4.6]: https://github.com/rust-lang-nursery/log/compare/0.4.5...0.4.6
[0.4.5]: https://github.com/rust-lang-nursery/log/compare/0.4.4...0.4.5
[0.4.4]: https://github.com/rust-lang-nursery/log/compare/0.4.3...0.4.4
[0.4.3]: https://github.com/rust-lang-nursery/log/compare/0.4.2...0.4.3
[0.4.2]: https://github.com/rust-lang-nursery/log/compare/0.4.1...0.4.2
[0.4.1]: https://github.com/rust-lang-nursery/log/compare/0.4.0...0.4.1
[0.4.0]: https://github.com/rust-lang-nursery/log/compare/0.3.8...0.4.0
[release tags]: https://github.com/rust-lang-nursery/log/releases

Գրաֆիտի („գրաֆիտո“ լատիներեն նշանակում է «քերթել»), այս բառով բնորոշվել են մարդկային առաջին նկարչական քայլերը, այսինքն՝ մարդու նախնիների կողմից քարով քերթված պատկերները քարանձավների պատերին, որտեղ պատկերված էին որսի դրվագներ, կենդանիների և մարդկանց նկարներ և այլն։

Ինչպես և որտեղ է ստեղծվել 

Այժմեական մշակույթում Գրաֆիտի անվանում են փողոցային պատերին արված պատկերները, հաճախ անվանելով նաև վանդալիստական ակտ, քանի-որ այդ կերպ արտահայտելով իրենց մտքերը, նկարիչները նաև խախտում են շինության ընդհանուր տեսքը, ինչևէ մարդկանց կարծիքները բազում է այս երիտասարդ մշակույթի վերաբերյալ։ Իսկապես լինում են միանշանակ վանդալիստական ակտեր Գրաֆիտիի միջոցով, բայց և ստեղծվում են իսկապես հարգանքի արժանի արվեստի գործեր, որոնց հեղինակների յուրօրինակ աշխատանքը տեսնելով, դժվար է դասել նրանց վանդալիստների շարքերում։

Գրաֆիտի նկարողներին անվանում են վրայթեռներ, անգլերեն writer, որը նշանակում է գրող, իսկ քանի որ գրաֆիտին հիմնականում լինում է ինչ-որ բառի տեսքով, ապա նկարչին էլ անվանում են գրող։

Այսօրվա գրաֆիտին ստեղծվել է 1960-ականներին Ամերիկայի Միացյալ Նահանգներում, ի սկզբանե այն ունեցել է բավականին մռայլ իմաստ։ Փողոցային հանցագործ միավորումները, գրելով սեփական միավորման անունը պատերին, նշել են այն բոլոր տարածքները, որտեղ ըստ իրենց դրված օրենքների պետք է գործեն իրենք, այդ կերպ պայմանավորվածություն ստեղծելով այլ միավորումների հետ համատեղ քաղաքի բաժանման համար։ Իհարկե այս առանձնահատման ձևը նաև օգնել է օրինապահ ուժերին, իրենց ի դեմս հանցագործների պայքարի մեջ և Գրաֆիտին դարձել է ոչ օգտակար ձև նշվելու հանցագործների համար, այն հետզհետե դարձել է ավելի վանդալիզմի նման երևույթ, իսկ իր զարգացման ընթացքում նաև ստանալով նոր որակ և երիտասարդության կողմից այլ տեսակետից նայվելով դարձել է տեխնիկապես բարդ և նույնիսկ կոմերցիոն արժեք ունեցող նկարչական ուղղություն։

Գրաֆիտին թերևս չի համարվում պրոֆեսիոնալ նկարչական ոճ, բայց մեծ համբավ ունի երիտասարդության և հասուն մարդկանց շրջանակներում, այդ պատճառով բավարարվում է ինքնազարգացմամբ, որն իսկապես աշխատում է ազատամտության և էնտուզիազմի հաշվին։ Այսօր գրաֆիտին ոչ միայն նկարչական նշանակություն ունի, այլ նաև իմաստավոր, քանի որ երիտասարդությունը շատ հաճախ պատերին նկարված պատկերների և բառերի միջոցով անդրադառնում է իրեն հուզող հարցերին, օրինակ 2004 թվականին նկատվել են բազում նկարազարդված պատեր ամբողջ աշխարհում նկարված Իրաքյան պատերազմի թեմատիկայով։

Գրաֆիտիի ոճերը 
Գրաֆիտին, չնայած իր բավականին նոր ուղղություն լինելու հանգամանքին, ունի մի շարք ոճեր. Դրանք են՝ Բաբլ սթայլ (Bubble style), Սթրիթ սթայլ (Street style), Քերեքթր (Character), Էֆեքս (FX)։

Բաբլ սթայլ 
(Bubble style), Bubble՝ նշանակում է փուչիկ, style՝ ոճ, այսինքն փուչիկային ոճ, երևի արդեն պարզ է թէ ինչպիսին կլինի այս ոճի տեսքը։ Գրաֆիտիի այս ձևը տեխնիկապես ամենահեշտն է և համբավ ունի սկսնակ նկարողների՝ ռայթեռների մոտ, այն իր նկարչական մոտեցումով ավելի նման է մուլտիպլիկացիոն տառատեսակի, քանի որ Բաբլ ստայլով նկարվում են միայն բառեր։

Սթրիթ սթայլ 
(Street style), այսինքն փողոցային ոճ։ Այս ոճը համեմատաբար ավելի տեխնիկապես բարդ է և համարվում է ամենասիրված ոճը, այն նաև ամենատարածվածն է։ Այս ոճով նկարվում են միայն բառեր, որոնք հաճախ այնքան խճճված են պատկերվում, որ միայն հեղինակն է ի վիճակի կարդալ։ Հիմնականում պետք էլ չէ հասկանալ պատին գրվածը, քանի որ հեղինակը ամենայն հավանականությամբ սեփական մականունն է գրում, այդպես է ընդունված այս ոճում, քանի որ շեշտը դրված է ոչ թէ բառի իմաստի վրա, այլ նրա գեղարվեստական հարստության, գույնի և ֆորմայի գեղեցկության վրա։ Չնայած նրան որ այս գրաֆիտիները անհասկանալի են կարդացողի համար, հաճախ հանդիպում են այնպիսի նմուշներ, որոնց նայողը երկար չի կարողանում պոկ գալ։

Քերեքթըր 

(Character), այսինքն կերպար։ Այս ոճին հավատարիմ նկարիչները պատկերում են մարդկային դիմանկարներ, կամ կենդանիների, մի խոսքով ամեն ինչ կապված կերպարվեստի հետ, հաճախ հանդիպում են պատեր հայտնի մարդկանց դիմանկարներով, օրինակ քսաներորդ դարի վերջին շատ մոդայիկ էր 2Pac-ի և Չե Գեվարայի դիմանկարները, որոնք ասես տպվում էին մեկը մյուսի հետևից։

Էֆեքս 

(FX), FX-ը effects անգլերեն բառի սլենգային գրվածքն է, գտնելով որ այդ բառը գրել այնպես ինչպես այն հնչում է ավելի մոտ է Գրաֆիտիի կոնցեպտին այն այդպես էլ գրում են, հայտնի է այս ոճը նաև Մյուրալիզմ անվանումով, որն օգտագործվում է հիմնականում Եվրոպայում, քանի-որ շատերի կարծիքով այն սկիզբ է առել Ֆրանսիայում։ Այս ոճը տեխնիկապես և իր բնույթով ամենադժվարն է, քանզի այստեղ պահանջվում է արդեն տարիների փորձ և գեղարվեստական բացառիկ որակ։ ԱՄՆ-ում և Եվրոպայում այս ուղղությունը մեծ համբավ ունի սրճարանների, ակումբների և նույնիսկ գրասենյակների ձևավորման ասպարեզում և վարձատրվում է մեծ գումարներով։ Լինում են դեպքեր, երբ նաև վաճառվում են կտավի վրա, ինչպես կվաճառվեր գեղանկարը, դա խոսում է որակի և բարդ մասնագիտական աշխատանքի մասին։ Աշխարհում շատ քիչ գրաֆիտիի մասնագետներ կան, որոնք նկարում են այս ոճով, հիմնականում նրանց տարիքն անցնում է երեսունը, իսկ սկսել են նրանք տասնչորս-տասնհինգ տարեկանից, ինչը խոսում է փորձի մասին։ Այս ոճից է սկիզբ առել աերոգրաֆիան, որը նման ոճի նկարչություն է միայն մեքենաների վրա։

Գրաֆիտիի ժամանակակից արքաներից են՝ Loomit, Daim, Codeak,Seen,Cope և այլք։ Հայաստանում նույնպես կան ռայթեռներ, նրանցից են՝ Free Art, Van, Ray, Toxic, և այլք։ Կան նաև անհատական նկարողներ, որոնցից առավել հայտնին Հայաստանում Key անունով երիտասարդն է։

Գեղանկարչություն
Արվեստի ժանրեր

#![allow(dead_code, unused_imports)]

use log::{debug, error, info, trace, warn, Level, LevelFilter, Log, Metadata, Record};
use std::sync::{Arc, Mutex};

struct State {
    last_log_level: Mutex<Option<Level>>,
    last_log_location: Mutex<Option<u32>>,
}

struct Logger(Arc<State>);

impl Log for Logger {
    fn enabled(&self, _: &Metadata) -> bool {
        true
    }

    fn log(&self, record: &Record) {
        *self.0.last_log_level.lock().unwrap() = Some(record.level());
        *self.0.last_log_location.lock().unwrap() = record.line();
    }
    fn flush(&self) {}
}

#[test]
fn test_integration() {
    // These tests don't really make sense when static
    // max level filtering is applied
    #[cfg(not(any(
        feature = "max_level_off",
        feature = "max_level_error",
        feature = "max_level_warn",
        feature = "max_level_info",
        feature = "max_level_debug",
        feature = "max_level_trace",
        feature = "release_max_level_off",
        feature = "release_max_level_error",
        feature = "release_max_level_warn",
        feature = "release_max_level_info",
        feature = "release_max_level_debug",
        feature = "release_max_level_trace",
    )))]
    {
        let me = Arc::new(State {
            last_log_level: Mutex::new(None),
            last_log_location: Mutex::new(None),
        });
        let a = me.clone();
        let logger = Logger(me);

        test_filter(&logger, &a, LevelFilter::Off);
        test_filter(&logger, &a, LevelFilter::Error);
        test_filter(&logger, &a, LevelFilter::Warn);
        test_filter(&logger, &a, LevelFilter::Info);
        test_filter(&logger, &a, LevelFilter::Debug);
        test_filter(&logger, &a, LevelFilter::Trace);

        test_line_numbers(&logger, &a);
    }
}

fn test_filter(logger: &dyn Log, a: &State, filter: LevelFilter) {
    // tests to ensure logs with a level beneath 'max_level' are filtered out
    log::set_max_level(filter);
    error!(logger: logger, "");
    last(a, t(Level::Error, filter));
    warn!(logger: logger, "");
    last(a, t(Level::Warn, filter));
    info!(logger: logger, "");
    last(a, t(Level::Info, filter));
    debug!(logger: logger, "");
    last(a, t(Level::Debug, filter));
    trace!(logger: logger, "");
    last(a, t(Level::Trace, filter));

    fn t(lvl: Level, filter: LevelFilter) -> Option<Level> {
        if lvl <= filter {
            Some(lvl)
        } else {
            None
        }
    }
    fn last(state: &State, expected: Option<Level>) {
        let lvl = state.last_log_level.lock().unwrap().take();
        assert_eq!(lvl, expected);
    }
}

fn test_line_numbers(logger: &dyn Log, state: &State) {
    log::set_max_level(LevelFilter::Trace);

    info!(logger: logger, ""); // ensure check_line function follows log macro
    check_log_location(state);

    #[track_caller]
    fn check_log_location(state: &State) {
        let location = std::panic::Location::caller().line(); // get function calling location
        let line_number = state.last_log_location.lock().unwrap().take().unwrap(); // get location of most recent log
        assert_eq!(line_number, location - 1);
    }
}

Geocaching (anglicky , v češtině také často ) je hra na pomezí sportu a turistiky, která spočívá v použití navigačního globálního družicového polohového systému při hledání skryté schránky nazývané cache (v češtině psáno i keš), o níž jsou známy její zeměpisné souřadnice. Při hledání se používají turistické navigační přístroje či chytré telefony. Člověk zabývající se geocachingem bývá označován slovem geocacher, česky též geokačer nebo prostě kačer. Po objevení cache, zapsání se do logbooku (deníku) a případné výměně obsahu ji nálezce opět uschová a zamaskuje.

Všeobecně oceňovaným prvkem geocachingu je umisťování keší na místech, která jsou něčím zajímavá a přesto nejsou turisticky navštěvovaná. V popisu cache (listing) jsou pak uvedeny informace o místě s jeho zvláštnostmi a zajímavostmi. Cache se ale umisťují i do zajímavých míst velmi frekventovaných. V některých případech je zajímavým právě úkol, který je s nalezením cache spojen.

V současnosti (2020) existují přibližně 3 miliony keší ve 191 zemích světa, na všech kontinentech včetně Antarktidy. Ve světě existuje více než 200 geocacherských organizací.

Cache 

Cache bývá voděvzdorná, většinou plastová schránka, kanystr, apod. Zakladatel cache (owner – majitel) po jejím umístění zveřejní její souřadnice na některý internetový server zabývající se geocachingem. Schránka by měla být dostatečně veliká, aby se do ní vešel deník (tzv. logbook), do něhož se zapisují její nálezci. Bývá zvykem umísťovat do cache také nějaké předměty na výměnu. Nálezce cache si smí takový předmět vzít (a například přenést do další cache), ale musí místo něj vložit něco vlastního (jiný předmět) pro další účastníky hry, o stejné nebo vyšší hodnotě.

Pravidla 
Cache musí být od sebe vzdálené minimálně 0,1 míle, což je 161 metrů. Keše schvaluje a publikuje reviewer. Revieweři jsou dobrovolníci, kteří mají na starost publikování keší ve stanoveném území. Umístění keše musí dodržovat veškeré místní zákony, na soukromém majetku vyžadují souhlas majitele objektu. Dle regionálních pravidel v Česku se nesmějí zakládat na hřbitovech, dětských hřištích, základních a mateřských školách, nesmějí být zakopané hluboko pod zemí, ve vojenských prostorech atd.

Obsah cache 
Schránka by měla vždy obsahovat alespoň logbook a informaci pro náhodné nálezce („mudlokarta“). Schránka (nebo alespoň logbook) by měla být jednoznačně označena názvem cache.

Vhodným doplňkem základního obsahu cache je pak ještě tužka, uzavíratelný plastový sáček pro vodotěsné uložení logbooku a tužky a náhradní plastový sáček pro zabalení schránky (pokud je schránka od zakladatele takovým sáčkem opatřena).

Logbook, mudlokarta, vlastní schránka, obal, tužka, případně ořezávátko je stálou součástí cache, a nesmí se z ní odnášet, ani výměnou za jiné předměty!

Pokud to rozměry schránky cache dovolí, může zakladatel cache přiložit drobné předměty na výměnu, nebo trackovatelné předměty (TB nebo GC – viz níže).

Pokud nálezce v cache neobjeví žádný předmět na výměnu, nebo se mu žádný nelíbí, nemusí si jej vzít. Může v cache ale zanechat jiný takový drobný předmět. Rozhodně by si ale neměl vzít žádný předmět z cache, aniž by do cache jiný předmět o stejné nebo vyšší hodnotě výměnou vložil. Celková hodnota obsahu cache se nesmí výměnou snížit. Vhodnost konkrétních předmětů pro vložení do cache je dána jednak velikostí schránky, ale také představou, že nejčastějšími geocachery, kteří se na výměnu těší, jsou malé děti. Naprosto nevhodné jsou tedy předměty jako peníze (s výjimkou symbolických platných mincí jako např. jednotlivé mince cizích měn), cigarety, plynové zapalovače, předměty s nemravným vyobrazením apod. Nepřípustné je vkládání jakýchkoliv potravin (žvýkačky, sušenky, bonbony…).

Speciální předměty v cache 

V keších je možné nalézt i speciální trasovatelné předměty. Jsou to buď Travel Bugy (udávána mezinárodní zkratka TB, označováno jako TBxxxxx) – předměty opatřené speciální kovovou známkou s unikátním identifikačním kódem, nebo geocoiny (udávána mezinárodní zkratka GC, nebo též počeštěně geomince) – speciální mince s unikátním identifikačním kódem. Každý takový předmět má svůj úkol (anglicky current goal), který je uveden na serveru nebo přímo u travelbugu či geomince na kartičce či jiném prvku. Current goal obsahuje zpravidla cestovní cíl travelbugu či geomince (např. „docestovat do Japonska“), nebo jiné přání ownera (např. „travelbug musí přebývat v keších blízko vody“). Pro travelbug se užívá také zkratka TB a pro geocoin GC.

Pokud nalezená cache obsahuje TB nebo GC, může se geocacher rozhodnout, zda předmět (nemusí být výměnou za jiný předmět) z cache odnese (a pokusí se splnit či pomoci splnit jeho úkol co nejrychlejším přenesením do další cache podle jeho „current goal“), nebo zda si TB resp. GC pouze prohlédne (a poznamená jeho unikátní kód pro pozdější registraci na serveru). Nemusí však volit žádnou z těchto možností a tyto předměty může ignorovat.

Kromě TB a GC, registrovatelnými na serveru Geocaching.com, se občas objevují i jiné trasovatelné předměty. Tyto jsou ale trasovatelné pomocí jiných serverů (např. geokrety.org, www.geotrackables.com, www.geolutins.com). Tyto aktivity jsou zpravidla organizované jednotlivci nespokojenými se skutečností, že s pořízením TB či GC je nutné (kromě výrobní ceny geocoinů) zaplatit drobný poplatek (jednotky dolarů) určený k financování provozu serveru.

Geocacher, který chce být majitelem TB či GC (a s určením nějakého „current goal“ jej vložit do nějaké cache), má možnost je získat pomocí některého z mnoha internetových obchodů zaměřených výhradně na prodej tohoto typu zboží a jiných doplňkových „geocaching“ předmětů (turistických navigačních přístrojů, oblečení, plastových schránek apod.)

Typy skrýší (caches)

Podle velikosti 

 Nano – nejmenší schránka. Nevejde se do ní tužka a většinou obsahuje pouze „logbook“, který je i tak velmi malý (příkladem může být i GeoKnots Logsheet Roller). Tato velikost nemá podporu na geocaching.com, proto jsou keše této velikosti uváděny buďto jako Micro nebo Other.
 Micro – velmi malá schránka (podle pravidel menší než cca 1 dl, tzn. patří sem i tzv. „nano-cache“). Typicky lehce upravená a přizpůsobená krabička od filmu, od bonbonů tic-tac, od léků apod. Často je také používán prefabrikát PET lahví. Pro její možnost umístit ji nenápadně i do frekventovaných prostor se používá nejčastěji pro keše v centrech měst apod. Micro-cache bývá doplněna magnetem pro snadnější uchycení na kovových konstrukcích a bývá i velmi umně maskována tak, aby co nejlépe splynula s okolím. Pro svoji miniaturní velikost se do micro-cache zpravidla nemohou vkládat žádné předměty na výměnu, ale téměř výhradně pouze logbook a případně tužka.
 Malá – malá schránka, přibližně o objemu malé krabice na ohřívání potravin v mikrovlnné troubě, která se také jako schránka často používá. Small-cache obsahuje logbook a menší předměty na výměnu.
 Střední – schránka běžné velikosti, vejdou se do ní kromě logbooku i větší předměty na výměnu, malé plyšové hračky apod. Často se pro ni používají běžné krabice na ohřívání potravin v mikrovlnné troubě.
 Velká – specializované výjimečné schránky, jejichž nadměrná velikost bývá zaměřena speciálně pro ukládání větších předmětů na výměnu (např. knih a CD).
 Other – schránka neurčitelné velikosti. Může to být například placatá magnetická nálepka nebo kniha v knihovně. Nově se touto velikostí označují i earthcache a eventy.

Podle charakteru 
 Tradiční cache (český výraz tradička) – schránka je umístěna přímo na místě definovaném souřadnicemi zveřejněnými registrovaným členům.
 Multi cache – k nalezení cílové (tzv. finální) skrýše je potřeba nalézt nejprve skrýš první (či splnit úkol či vyluštit šifru) danou zveřejněnými souřadnicemi a z informací získaných v první skrýši nalézt skrýš finální, případně druhou, třetí a další, postupně je nutné se propracovat až na tzv. finální skrýš. Multi cache mohou mít mnoho podob, spojuje je ale shodná filosofie postupného hledání řetězce pomocných skrýší nebo plnění úkolů směřujících k nalezení skrýše hlavní. Jednotlivé pomocné skrýše se nazývají stage (z angl. stage, tj. stupeň).
 Mystery cache (český výraz mysterka) – zveřejněné souřadnice ukazují zpravidla do blízkého okolí cache, ale skutečné souřadnice musí geocacher dopředu získat například prostudováním nějakých informací, vyluštěním hádanky, šifry apod. Někdy se též tato cache nazývá unknown (tj. neznámá).
 Webcam cache (český výraz webka) – speciální cache, která neobsahuje ukrytou schránku, ale přivede geocachera před objektiv konkrétní popsané webkamery. K virtuálnímu „odlovení cache“ pak stačí, aby jiná osoba snímek z webkamery dostupný na internetu uložila. Geocacher pak uložený snímek přiloží jako důkaz k elektronickému logu cache. Nové webcam cache již nelze od konce roku 2005 na serveru Geocaching.com zakládat.
 Letterbox hybrid – Kombinace geocachingu a starší hry letterboxing. Hledání skrýše probíhá jen z části pomocí navigačního přístroje; z části pak podle různých indicií (např. slovní popis cesty, fotografie). Oproti tradiční cache obsahuje navíc razítko, které si nálezce může otisknout do svého deníčku.
 Virtuální cache (český výraz virtuálka) – na zadaných souřadnicích není ukryta žádná skutečná schovaná schránka. Geocacher musí na hledaném místě něco zjistit (např. jména na pomníku apod.) a odeslat tyto informace ownerovi cache pro uznání logu. Tyto cache již není možné na geocaching.com zakládat, ale je možné je stále hledat. V srpnu 2017 dostalo 4000 geokačerů možnost založit novou virtuální kešku. Hráči s touto možností byli vybráni pomocí speciálního algoritmu, který hodnotil například kvalitu jimi založených kešek. Dále byli takto „odměněni“ hráči významně se podílející na chodu geocachingu. Tito hráči mohou svoji odměnu v podobě založení nové virtuálky uplatnit až do srpna 2018.
 Earthcache (český výraz earthka) – obdoba virtuálních keší. Earthcache se zakládá v místech s geologickou či jinou zajímavostí týkající se planety Země. Podobně jako u virtuálních cachí není úkolem najít cache, ale dojít na dané místo, zjistit nějaké informace, udělat fotografie atd. Vždy záleží na zakladateli, jaké podmínky pro uznání logu stanoví.
 Event cache – setkání geocacherů. Společenská událost spojená např. s určitým programem (např. CITO). Na setkání může dojít k hromadné výměně travelbugů nebo geocoinů. Opravdu velká setkání mohou být za určitých podmínek označena jako Mega Event. V srpnu 2014 se konal v Mnichově i první Giga Event. V České republice se první Giga Event konal ve dnech 1.–3. 9. 2017 na Plumlově. Zároveň šlo o jediný Giga Event v roce 2017 na světě. Na Mega Eventech a Giga eventech jsou také Lab Cache, kešky u nichž je třeba zadat kód
 Cache In Trash Out Event (CITO) – setkání (event), na kterém se geocacheři snaží vyčistit vybrané území od nepořádku a odpadků, které v přírodě ponechali lhostejní lidé. Je to společenské setkání spojené s ekologickým chováním geocacherů k přírodě.
 Wherigo cache (český výraz wigo) – spojení geocachingu a hry wherigo. Od klasického wheriga se liší jen tím, že na konci cesty je keška.
 Members Only Cache (prémiové kešky) – každý typ keše s výjimkou eventů, megaeventů, gigaeventů, lab keší a CITO eventů může být dostupný jen pro prémiové členy

Podle obtížnosti a terénu 
S růstem popularity a dostupnosti geocachingu vznikla mezi částí geocacherů touha po větší exkluzivitě – touha po hledání geocache (tzv. kešek), které nedokáže dosáhnout každý a s jejichž odlovem je často spojena určitá míra adrenalinu, případně i obtížné luštění šifer. Tento typ kešky je některými geocachery nazýván drsnokeš. Možné umístění zahrnuje skály, přírodní i městské podzemí, nedostupné stromy atd. Tyto složitě dostupné kešky se v geocachingovém slangu označují jako tépětky (T5; mají nejvyšší terénní obtížnost – vyjádřenou stupněm 5).

Každá keš má číselně označený terén a obtížnost. Škála je po polovinách celých čísel od 1 do 5.

Server Geocaching.com 
Nejstarší a nejvíce využívaný server je geocaching.com, provozovaný společností Groundspeak v USA v Seattle. Server umožňuje registrovaným uživatelům prohlížet
cache na libovolném místě po celém světě. Také si zde uživatel vede svůj online log, do kterého si zapisuje nálezy. Kromě některých soukromých údajů jsou veškerá data (logy, fotografie, osobní statistiky) přístupná všem registrovaným uživatelům serveru. Každý tak může sledovat nejen vlastní nálezy jednotlivých cache, ale najít si i statistiky nálezů jiných lovců.

Server také umožňuje sledování trasovatelných předmětů, takže lze získat informace o „current goal“ nalezeného TB či GC, stejně tak i o historii putování či aktuální pozici konkrétního TB či GC.

Alternativní servery 

Přístup provozovatele serveru Geocaching.com se časem přestal líbit některým jeho uživatelům, kteří se začali sdružovat k provozování vlastních variant hry. Jestliže se např. TerraCaching zaměřuje na vysokou kvalitu keší a neumožňuje registraci keše zároveň na jiných serverech (tzv. double-listing), Opencaching Network volně sdružující jednotlivé národní projekty, dává důraz na maximální otevřenost, komunitnost a nekomerčnost (tzv. double-listing je zde dovolen, ale není doporučován). V roce 2010 pak vznikl projekt OpenCaching.com, který (spolu s důrazem na jednoduchost) deklaroval podobné cíle jako projekty sdružené v Opencaching Network (otevřenost, komunitnost, nekomerčnost), ale na rozdíl od těchto nezávislých projektů byl OpenCaching.com provozován a řízen firmou Garmin, populárním výrobcem turistických navigací. Dne 21. srpna 2015 Garmin oznámil ukončení provozu OpenCaching.com.

České servery 
K 15. výročí Geocachingu (2. května 2015) byl spuštěn oficiální Průvodce Geocachingem na webu kesky.cz, který přehledně zpracovává jednotlivé tematické okruhy v českém jazyce – základy Geocachingu, hledání keší, zakládání keší, eventy, trackovatelné předměty, aplikace pro Geocaching a výbava pro Geocaching. Průvodce navíc zahrnuje aktuální přehled plánovaných geocachingových akcí (eventů) na území České republiky.

Největším diskuzním serverem české komunity geocacherů je server Geocaching.cz, obsahující diskusní fórum českých geocacherů s mnoha tématy, informace o zajímavých programech, webech, chystaných setkáních apod. Dále existuje i několik regionálních serverů pro Plzeň (Geocaching Community Plzeň), Brno (K. G. Brno), Olomouc (Olomoucké geokačerstvo), jižní Čechy (Geojih – Geocaching na jihu Čech), západní Čechy (Geowest), Beskydy a Ostravu (BO!!!GEO – Beskydsko-Ostravský geocaching), či Kladensko a okolí (GeoKladno).

Existuje také Česká asociace geocachingu (tzv. ČAGeo) sídlící v Chrastavě (dříve v Horoměřicích), jedná se o občanské sdružení, které není nijak spojeno s provozovatelem hry. Má ve svých stanovách určen jako cíl zlepšení úrovně geocachingu v České republice. Její největší úspěch je organizace eventu MAZE a první uvedení nového typu kešek Lab Cache (obě mají vlastní ikonu). Čageo často vyvolává rozporuplné reakce zejména svými prvními kroky, podle diskusí na fóru www.geocaching.cz.

Alternativní proudy geocachingu jsou v Česku zastoupeny serverem 'OpenCaching.com' a českou verzí 'Opencaching.cz'. Zdá se, že obě tyto alternativy jsou prozatím z nejrůznějších důvodů na okraji zájmu české geocacherské komunity. Zatímco Opencaching.cz (vzniklý v r. 2006 jako reakce na komerční základ některých služeb na Geocaching.com) v polovině roku 2012 hlásil 400 aktivních keší, na mapě OpenCaching.com, který vznikl v roce 2010, bylo možné v polovině r. 2012 nalézt v Česku necelých 200 keší, zatímco na Geocaching.com jich již v roce 2008 bylo téměř 12000.

Historie a současnost 
Geocaching vznikl v USA bezprostředně poté, co 1. května 2000 rozhodnutí tehdejšího amerického prezidenta Clintona odstranilo umělou odchylku, přidávanou do signálu GPS, a zlepšilo tak přesnost tohoto navigačního systému pro běžné civilní uživatele z desítek až stovek na několik metrů.

K červnu 2005 bylo ve 215 zemích na celém světě přes 171 000 skrýší pro geocaching, z toho zhruba 700 v Česku. V září roku 2006 vzrostl počet skrýší v Česku na celkem 2570 a český geocaching dále prožíval svůj boom, neboť v listopadu 2007 bylo na českém území zaregistrováno již přes 5600 skrýší. Na začátku března 2008 bylo na světě registrováno přes půl milionu míst, z toho 6600 v Česku. Podle statistik serveru geocaching.com najde alespoň jednu cache za týden v průměru kolem 50 tisíc lidí. V ČR bylo založeno do 30. listopadu 2008 11496 keší, a do 31. srpna 2009 15707 keší V červenci 2012 dosáhl počet keší na celém světě čísla 1,5 milionu. V lednu 2014 dosahuje počet keší v systému Geocaching.com celosvětově 2,3 milionu, počet geocacherů přes 6 milionů. Počet aktivních keší v ČR je na počátku roku 2015 přes 40 tisíc, aktivních geocacherů kolem dvaceti tisíc.

Komunita geocacherů organizuje rozmanité kolektivní akce („setkávací“ cache) s programem jako jsou např. úklidy v přírodě, geosetkání, geohry (viz výše CITO cache, Event cache).

Geocaching se těší velké popularitě zejména ve střední a severní Evropě. Nejvíce nálezů na světě má geocache na Karlově mostě v Praze.

Kontroverze a problémy 
Cacheři při dohledávání geocache bývají konfrontováni policií, s dotazem, co provádí na místě keše. V jiných případech dohledávání geocache na místě uložení vyústilo v informování záchranných složek o podezřelé aktivitě. Došlo k tomu, že veřejné budovy či školy byly evakuovány, když učitelé či policejní jednotky objevili geocache, jako se stalo v případě střední školy Fairview High School v roce 2009. V několika případech byl obsah geocache zneškodněn pyrotechnickými jednotkami, protože existovalo podezření, že v krabičce je uschován nástražný výbušný systém. Rozličné oblasti, od starých hřbitovů po Disneyland, byly v důsledku nalezení geocache přechodně uzavřeny pro veřejnost.

Umístění geocachí bývá někdy terčem kritiky vládních orgánů či veřejnosti. Geocache bývají zaměněny s odpadem. Někteří geocacheři však při hledání geocache odpad z místa umístění naopak odnáší, tato praktika je úzce spojena s tzv. CITO eventy (Cache-In-Trash-Out). Eventy a geocache jsou často spojeny s ekologií a úklidem odpadu, mnoho oblastí tak vypadá čistěji, než bylo dříve a nejsou k tomu zapotřebí státní či lokální finanční zdroje. Geocaching není v USA protizákonný a obvykle je v případě, že je vysvětlen úředníkům, vnímán pozitivně. Nicméně, některá umístění geocache mohou být problematická. Ačkoliv je v pravidlech Groundspeaku zakázáno umisťovat geocache na soukromý majetek bez adekvátních povolení, tak se to stává a posléze je možné, že ostatní geocacheři mohou neoprávněně vniknout na cizí pozemek. Geocache také mohou být uschovány na místech, kde samotné dohledávání může vypadat podezřele (např. blízko škol, dětských hřišť, bank, soudů nebo v rezidentních oblastech). Podobný případ také může nastat, pokud je cache umístěna na místě, kde může být zaměněna za drogový balíček či bombu (speciálně v místech, kde se pohybuje mnoho lidí, pod mosty, poblíž bank, soudů či ambasád). I přes zmíněné problémy s odpadem či nástražnými výbušnými systémy, mohou někteří geocacheři umístit geocache na nebezpečná místa. Ukrytí geocache na těchto místech se nedoporučuje a webové stránky spojené s ukládáním geocachí se snaží vynutit dodržování pravidel a doporučují zakázat některé typy umístění. Nicméně, reviewři (uživatelé schvalující geocache) zpravidla nemohou přesně vidět kde a jak je každá jednotlivá geocache schovaná. Konečně, největší díl zodpovědnosti je na samotných geocacherech, mají možnosti reportovat problémy s umístěním geocache a také si musí počínat s nejvyšší opatrností.

Regionální pravidla pro ukládání geocachí mohou být poměrně komplexní. Například, ve Virginii Virginské Oddělení dopravy (Virginia Department of Transporation) a Agentura pro správu divoké přírody (Wildlife Management Agency) nedávno zakázali ukládání geocachí na všech územích pod kontrolou těchto organizací. Některá města a rekreační oblasti povolují ukládání geocachí s málo či žádnými omezeními, jiná však vyžadují komplikovaná povolení.

Rada Jižní Karolíny schválila v roce 2005 zákon č. 3777, ve kterém stojí: „Je zakázáno provozovat geocaching či letterboxing na hřbitově nebo na historickém či archeologickém nalezišti nebo na nemovitosti veřejně označené jako historická památka bez přímého písemného svolení správce hřbitova či pozemku.“ Zákon byl schválen při prvním čtení v Senátu a od té doby je platný.

Tři dospělí geocacheři, 24letá žena a její rodiče byli při hledání ammoboxu uvězněni v jeskyni a zachráněni hasiči v Rochesteru, ve státě New York. Mluvčí Rochesterských hasičů plk. Ted Kuppinger sdělil: „Je to komplikované, protože pokud se snažíte najít něco takového, tak se pravděpodobně pokusíte překonat sami sebe a přeceníte svoje síly.“

Úmrtí při geocachingu 
Při geocachingu zemřelo několik osob. Úmrtí jedenadvacetiletého zkušeného geocachera v prosinci 2011 s tématem „při přístupu ke keši to nevypadalo tak nebezpečně“ vedlo k diskuzi na fórech Groundspeaku o změnách, které by měly být provedeny a o tom, zda by Groundspeak či majitelé geocachí měli nést zodpovědnost.

V červnu 2018 smetla přívalová povodeň čtveřici geokačerů v zatrubněné části Motolského potoka v Praze. Dva lidé v přívalové povodni utonuli.

Nejaktivnější geokačeři v České republice a jinde

svět 
Ve statistice evidováno 521 103 geokačerů světa v následujícím pořadí nálezů: 1. mondou2 (USA, Colorado) 214 940 nálezů, 2. Alamogul (USA, Kalifornie) 209 264 nálezů, 3. racer2814 (USA, Illinois) 145 785 nálezů, 4. IMSpider (USA, Delawere) 143 143 nálezů, 5, anonymní, 6. MT-Jonea (Česká republika) 135 734 nálezů, 7. Dave w/o id (USA, New York) 135 655 nálezů atd. (k 5. 3. 2021)

Zastoupení států u prvních 20. míst: 14 x USA, 2 x anonymní, po jednom zástupci Česká republika, Španělsko, Kanada a Francie.

Česká republika 
V České republice evidováno 39 012 geokačerů k 5. 3. 2021. Nejúspěšnějšími geokačeři: 1. MT-Jonea (135 734 nálezů), 2. werg (99 094 nálezů) a 3. otasparta (98 679 nálezů).

 Austrálie: 8 973 geokačerů, 1. místo Liz a Bruce 64 427 nálezů
 Francie: 20 666 geokačerů, 1. místo vilcanota 101 565 nálezů
 Německo: 151 046 geokačerů, 1. a 2. místo je anonymní a 3. místo geoteddybear 76 028 nálezů 
 Rakousko: 10 862 geokačerů, 1. místo Skihasen 78 070 nálezů
 Spojené království: 30 000 geokačerů, 1. místo Simplysup 73 402 nálezů
 USA: 113 592 geokačerů, 1. místo mondou2 214 940 nálezů

Odkazy

Reference

Literatura

Související články 
 Letterboxing
 Wherigo
 Waymarking
 Degree Confluence Project
 ROT13
 GEOFUN

Externí odkazy 
 
 
 
 www.geocaching.com – Oficiální stránka 
 kesky.cz – Oficiální český průvodce Geocachingem
 wiki.geocaching.cz – česká encyklopedie geocachingu
 www.geocaching.cz – český diskusní server
 www.cageo.cz – Česká asociace geocachingu
 navigovat.mobilmania.cz – Garmin spouští OpenCaching: porazí Geocaching?

 
Pobyt v přírodě
GPS
Venkovní hry

Події 
 18 травня — відкрито рух поїздів дільницями »Ясинувата — Синельникове» і «Казанка — Катеринослав». Зданий в експлуатацію залізничний міст через Дніпро.

Народились 
Див. також :Категорія:Народились 1884
 24 березня — Петер Дебай, нідерландський фізико-фімик, лауреат Нобелівської премії.
 8 травня — Гаррі Трумен, 33-й президент США (1945—1953 рр)
 23 травня — Даглас Фербенкс, актор
 18 червня — Едуар Даладьє, французький державний і політичний діяч
 7 липня — Ліон Фойхтванґер, німецький письменник
 12 липня — Амедео Модільяні, італійський художник і скульптор
 23 липня — Еміль Янінгс, німецький актор
 2 серпня — Ромуло Гальєгос, венесуельський письменник, просвітитель, президент Венесуели
 27 серпня — Венсан Оріоль, президент Франції (1947—1954 рр.)

 Померли Див. також :Категорія:Померли 1884''
 26 січня — Чубинський Павло Платонович, український етнограф, фольклорист, поет
 24 листопада — Воробкевич Григорій Іванович, український поет

1880-ті

# The Lodash Threat Model

The Lodash threat model defines what Lodash trusts and does not trust when executing within a JavaScript environment. Lodash is a general-purpose utility library that operates within the same trust boundaries as the code that calls it. Therefore, vulnerabilities requiring the compromise of trusted elements — such as the JavaScript runtime, the host environment, or developer-controlled inputs — lie outside the scope of this threat model.

For a vulnerability to be considered within scope, it must result from Lodash itself violating its documented behavior or failing to maintain integrity, confidentiality, or availability under its standard usage assumptions.


## Elements Lodash Does NOT Trust

1. **Data provided to Lodash functions**  
Lodash treats all input data (arrays, objects, strings, functions, etc.) as untrusted. It does not attempt to validate or sanitize the semantic correctness of inputs — it operates on values as they are given.  
*If an untrusted input can cause Lodash to execute behavior beyond what is documented — such as prototype pollution, type confusion, memory exhaustion, or code injection — that would indicate a security vulnerability.*

2. **Untrusted network sources or user-controlled data**  
Any input derived from unvalidated user input, network responses, file contents, or deserialized data is untrusted. Lodash does not perform input isolation or sandboxing.

3. **Tampering with Lodash internals at runtime**  
Modifying Lodash’s internal symbols, monkey-patching its functions, or overwriting internal references at runtime is outside the trusted boundary.  
*If such modification changes Lodash behavior, that reflects a compromise of trusted code, not a Lodash vulnerability.*


## Elements Lodash Trusts

1. **The JavaScript runtime and its standard library**  
Lodash assumes a correct, uncompromised runtime environment (e.g., Node.js, browser). Vulnerabilities in the runtime (e.g., prototype chain issues, engine crashes) are out of scope.

2. **The environment and its configuration**  
Lodash relies on the correct functioning of the host environment (Node.js, browser, Deno, etc.) and any global objects or APIs it uses (e.g., `Object`, `Array`, `Function`, `JSON`).

3. **The code that invokes Lodash**  
The application or library using Lodash is responsible for validating user input, performing security checks, and handling execution context appropriately.

4. **Installed package integrity**  
Lodash assumes that the package installed (via npm, cdn, etc.) has not been tampered with and originates from the legitimate Lodash distribution channel.  
*Supply-chain compromise or malicious clones are not considered Lodash vulnerabilities.*

5. **The privileges and permissions of the execution context**  
Lodash inherits the privileges of the user or process that invokes it. Misuse or over-privileged execution environments (e.g., running as root, or with excessive browser permissions) are not within scope.

## Examples of Vulnerabilities (in scope)

- **Prototype Pollution ([CWE-1321](https://cwe.mitre.org/data/definitions/1321.html))**  
  If a Lodash function (e.g., `merge`, `defaultsDeep`, or `set`) allows modification of `Object.prototype` properties via untrusted input (e.g., `__proto__` keys) due to insufficient sanitization, it is in scope.  
  This class of vulnerability has been observed in prior Lodash versions (e.g., [CVE-2019-10744](https://www.cve.org/CVERecord?id=CVE-2019-10744)).

- **Unexpected code execution ([CWE-94](https://cwe.mitre.org/data/definitions/94.html))**  
  If a Lodash method (e.g., `template()`) executes attacker-controlled input as code without documented warnings or sanitization requirements, that is a Lodash vulnerability (e.g., [CVE-2021-23337](https://nvd.nist.gov/vuln/detail/CVE-2021-23337)).

- **Denial of Service (DoS) through logic flaws ([CWE-400](https://cwe.mitre.org/data/definitions/400.html))**  
  If Lodash enters unbounded recursion, excessive memory usage, or hangs when operating on otherwise valid inputs within documented usage limits, this is a vulnerability in Lodash (e.g, [CVE-2020-28500](https://www.cve.org/CVERecord?id=CVE-2020-28500)).

## Security notice: `_.template`

The current implementation of `_.template` compiles template strings into executable code, which can lead to code injection when given untrusted input (e.g., [CVE-2021-23337](https://nvd.nist.gov/vuln/detail/CVE-2021-23337)). For that reason we consider it insecure and advise against its use.

We plan to remove `_.template` in Lodash v5. Until then it remains available; if you continue to use it, we recommend using only developer-controlled, static template strings and trusted data, and avoiding untrusted input (e.g. user-controlled data or unvalidated network content) in both the template string and the data passed to the compiled function.

## Examples of Non-Vulnerabilities (out of scope)

### Malicious Third-Party Packages ([CWE-1357](https://cwe.mitre.org/data/definitions/1357.html))

If a project includes a malicious dependency that overrides Lodash behavior or injects malicious code into Lodash’s namespace, it does not represent a Lodash vulnerability. Lodash trusts its runtime and installation context.

### Unvalidated Application Input

Applications using Lodash are responsible for input validation. Passing attacker-controlled data directly into Lodash functions (e.g., `_.merge(req.body, config)`) is an application bug, not a Lodash vulnerability.

### Prototype Pollution via Trusted Code

If a developer intentionally merges user input into global objects or fails to isolate data structures, that is a misuse of Lodash’s documented API, not a Lodash defect.

### Stateful or Accessor-Backed Path Arguments

Path arguments to Lodash functions are expected (and documented) to be data, not code. Functions like `_.get`, `_.set`, `_.pick`, `_.unset`, and `_.omit` take paths as strings or arrays of strings and numbers.

Getters, setters, and Proxies are code, not data. They run JavaScript code when a property is read, and they can't be serialized as JSON or sent over the wire. Something has to call `Object.defineProperty` (or equivalent) from inside the process to set them up.

If a report relies on a path element returning different values on different reads (a check/use mismatch), the attack needs code running inside the process, not just attacker-supplied data. That puts it outside Lodash's trust boundary; see "code that invokes Lodash" under [Elements Lodash Trusts](#elements-lodash-trusts).

### Inherent JavaScript Prototype Behavior

Lodash blocks writes to built-in prototypes. Keys like `__proto__` and `constructor.prototype` are filtered in `_.set`, `_.merge`, and similar functions. It does not and cannot block reads.

Reading inherited properties is how JavaScript works. `obj.constructor`, traversing `__proto__`, or reaching `Object.prototype` through normal property resolution are language semantics, not Lodash behavior.

If a report shows only read-only prototype access (e.g. `_.get(obj, 'constructor.prototype')` returning `Object.prototype`), it's describing JavaScript, not a Lodash vulnerability.

### Vulnerability Chaining and Gadgets

A Lodash vulnerability has to be exploitable through Lodash alone. If a report's impact depends on combining Lodash behavior with a separate bug in another library or application component, the bug is in the downstream code, not Lodash.

Gadget reports fall under this too. If a Lodash function produces an object shape that later causes a vulnerable function in some other library to execute code, the root cause is that library accepting the shape, not Lodash producing it.

### Vulnerabilities in the JavaScript Runtime or Platform

If a Lodash method triggers a bug in the JavaScript engine (e.g., V8, SpiderMonkey, JavaScriptCore) that leads to memory corruption or incorrect behavior, the vulnerability lies in the engine, not Lodash.

### Environmental Misconfiguration ([CWE-15](https://cwe.mitre.org/data/definitions/15.html))

Issues arising from misconfigured execution environments, such as running outdated Node.js versions or insecure Content Security Policies in browsers, are not considered Lodash vulnerabilities.

### Supply Chain Compromise

Tampering with Lodash packages in the npm registry, MITM attacks during installation, or local file system manipulation are not vulnerabilities in Lodash itself.


## Summary

Lodash is a utility library operating entirely within the trust boundary of its caller. Vulnerabilities in scope are limited to cases where **Lodash fails to uphold its documented behavior** in the presence of **untrusted input**, without assuming compromise of trusted components such as the runtime, the operating system, or the invoking application code.

#![cfg(feature = "kv")]
#![feature(test)]

use log::kv::Value;

#[bench]
fn u8_to_value(b: &mut test::Bencher) {
    b.iter(|| Value::from(1u8));
}

#[bench]
fn u8_to_value_debug(b: &mut test::Bencher) {
    b.iter(|| Value::from_debug(&1u8));
}

#[bench]
fn str_to_value_debug(b: &mut test::Bencher) {
    b.iter(|| Value::from_debug(&"a string"));
}

#[bench]
fn custom_to_value_debug(b: &mut test::Bencher) {
    #[derive(Debug)]
    struct A;

    b.iter(|| Value::from_debug(&A));
}

Asatro är en modern beteckning på de religiösa traditioner och seder som utövades av invånarna i Skandinavien från folkvandringstiden och under vikingatiden fram till religionsskiftet. Kunskapen om asatron bygger huvudsakligen på nedteckningar från kristen medeltid, men som förutsätts spegla en äldre muntlig tradition. Svenska akademiens ordbok definierar asatro som ”en nordisk naturreligion där polyteism och naturväsen är centrala inslag utbredd i nord-germanska länder innan kristendomens införande”.

Begreppet asatro 
Begreppet asatro myntades under 1800-talet, då den nationalromantiska, samnordiska synen på vikingatiden skapades, och ett stort intresse för förkristen mytologi väcktes också i Tyskland (med Richard Wagners operasvit som främsta exempel). SAOB:s första belägg för begreppet är från 1820. 
Under medeltiden användes benämningen fornsed (medeltida stavning: forn siðr eller fornum sid) –  – för att beskriva tron och sederna innan kristendomen.

Som synonym för asatro används ofta fornnordisk religion, men detta begrepp omfattar även andra förkristna nordiska religioner, såsom samisk religion, finsk religion och Nerthuskult. En del svenska akademiker har därför börjat använda begreppet fornskandinavisk religion som synonym till asatro för att avgränsa mot just samisk och finsk religion. Asatro avser religionen som fanns i perioden precis innan kristendomens införande, medan de förkristna religiösa uttrycken som fanns under bronsålder och stenålder i Norden skiljde sig från asatron.

Skriftliga och arkeologiska källor 

Det som är känt om asatrons trosuppfattningar kommer främst från kristna källor, antingen isländska sagor nedtecknade efter kristnandet genomförts på Island, eller från kristna grannar som verkat samtidigt som asatron varit levande i Skandinavien, till exempel Adam av Bremen. Även Cornelius Tacitus skrev om germanerna och deras trosuppfattningar. De viktigaste källorna till nordisk mytologi är den poetiska Eddan och Snorres Edda från 1200-talet.

Det finns även arkeologiska källor som ger oss ledtrådar till hur och var asatron utövas. Ortnamn ger ofta vägledning om vilka gudar och gudinnor som dyrkades på en viss plats och sambandet mellan dessa. I nordiska ortnamn ingår följande gudars namn: Tor, Njord, Ull, Frö, Oden, Ti (Tyr), Frigg, Fröja, med binamnet Härn (isländska "Hörn"), Vrind (isländska Rind), möjligen också Vidar, Balder, Höder och Skade. Av gudomlighetsnamn används gud, as, dis, troligen också van, medan det i personnamnen ingår Tor, Frö, Oden, möjligen också Ti, liksom gud, as, ragn (gudamakt), dis, alv samt benämningar på valkyrior. Guden Ull har efterlämnat spår i ett stort antal svenska ortnamn som Ulleråker och Ullevi. Så trots att Ull har en undanträngd roll i Eddorna, så tycks han haft en viktig roll i de lokala offerkulterna.

Bakgrund 
Asatron utgjorde aldrig ett sammanhängande religiöst system, varför man kan säga att Snorre Sturlasson med sin Edda var den som först sammanförde berättelserna till en helhet. Den förkristna nordiska asatron var alltså aldrig någon enhetlig religion i modern bemärkelse utan var snarare en etnisk religion eller naturreligion, som saknade grundare och fastställda lärosatser. Mytologin fungerade troligen som en sorts teoretisk överbyggnad till kulten, som hade mycket lite att göra med tro och mer med handlande, traditioner och värderingar i samband med naturen, vädret, årstiderna och mänsklig verksamhet.

Asatro tillhör de polyteistiska religionerna, och förutom gudar tror man även på olika naturväsen. Asatron är en del av en större familj av indoeuropeiska religioner där man även finner grekisk, romersk och slavisk fornreligion. Det finns även motsvarigheter till asatrons panteon i den indiska hinduismen. En teori hävdar att olika indoeuropeiska stammar (indier, greker, italiker, kelter, slaver, germaner) har ett gemensamt ursprung, möjligen från områden i närheten av Svarta Havet och att dessa sedan utvandrat till övriga Europa samt Asien. Detta är en förklaring till likheten i religion och språk mellan dessa olika länder. Se urindoeuropéer.

Religionshistorikern Georges Dumézil menade att det urindoeuropeiska samhället varit uppdelat i tre delar, liknande det indiska kastsystemet. Detta kallade han trefunktionalitetssystemet. Detta tretal menade han även gestaltade sig i de indoeuropeiska gudsuppfattningen; de indoeuropeiska religionerna, menade han, hade alltid tre gudar som motsvarade den romerska mytologins Jupiter (övergud), Mars (krigsgud) och Quirinus (samhällsbeskyddaren och jordbruksgud). Han utvecklade sedan resonemanget med att uppställa ett schema över tretalens respektive egenskaper:
Den första stod för suveränitet, intelligens och helighet, och fungerade fredsbevarande.
Det andra för kraft och styrka, särskilt avseende krig, och fungerade som rättvisans princip.
Det tredje för tillgivenhet, samhällets bevarande, odling och jordbruk.
I ”De nordiska gudarna: en undersökning av den skandinaviska religionen” (1939) överförde han tretalssystemet till Eddan, och menade att det motsvarade Oden, Tor och Frej i den nordiska mytologin där Frej motsvarade jordbruket, Oden överguden och Tor var en krigsgud.

Under folkvandringstiden, efter Roms fall, vällde de germanska folken in över den europeiska kontinenten. De hade inte undgått påverkan från medelhavskulturerna men sin gamla tro tog de med sig och med dem spred den sig över Europa. Omkring år 500–750 ersattes denna tro gradvis av kristendomen i anglosaxarnas England och merovingernas Frankrike, och liksom senare i Skandinavien verkade de båda trossystemen parallellt med varandra under den tiden. Under denna period, alltså strax innan vikingatiden inletts, hade asatron sin största utbredning: Samma eller likartade gudar dyrkades över hela norra och västra Europa.
Dock försökte aldrig anhängarna till asatron att omvända de kristna och det var dömt att bli en tidsfråga innan de konverterade till kristendomen. I Norden dröjde kristnandet dock omkring 500 år längre än på kontinenten: Först kristnades Norge (900–1000), sedan Island (år 1000, enligt sagorna genom ett alltingsbeslut), Danmark, och sist Sverige av alla germanska områden; även om kristnandet framskred i olika takt i olika delar av länderna. Att nordborna blev kristna tolkas som ett tecken på deras integrering i det europeiska värdesystemet: även om den personliga övertygelsen lät vänta på sig underlättade det handeln att låta döpa sig.

Under seklerna som följde kristnandet, innan den kristna undervisningen hunnit etablera den kristna andan, levde dessutom skaldekonsten fortfarande vid hoven. Skalder kunde använda kenningar, hänsyftningar till den nordiska mytologin, och veta att han blev omedelbart förstådd; "dvärgarnas skepp" var skaldekonsten; "Fröjas tårar" var guldet; "valkyriornas eld" svärdet, "korpens öl" blodet, etc.

Asatron har karaktär av ursprunglig nordeuropeisk religion som dominerade större delen av Nordeuropa, alltså Skandinavien, England, Tyskland, Nederländerna och Belgien, bland andra. Det mesta vi vet om denna tro härstammar dock från Norden och i synnerhet Island. Det är inte säkert att övriga germanska folk omfattade exakt samma trosföreställningar som de forntida nordborna. Troligen varierade asatrons sedvänjor och myter avsevärt mellan de olika germanska folken och över tid. Att de religiösa föreställningarna i hela Skandinavien dock varit väsentligen desamma finns det dock mycket som tyder på. Skandinavien kristnades dessutom bortåt 500 år senare än exempelvis Tyskland och England. Mest hårdnackade i den gamla tron var folken i Sverige, som höll fast vid den "forna seden" ända in på 1100-talet, och det finns till och med vittnesmål om att människor åkallade asarna så sent som på 1500-talet i Småland.

Kosmologi 

I eddadikten Valans spådom, Völuspá, återges, via en völva (spåkvinna), myter om skapelsen, konflikterna i världen och världsundergången. Forskningen har diskuterat om Snorres text ger uttryck för en cyklisk världshistoria eller om den med ett definitivt världsslut är påverkad av kristendomen. Völvan berättar om den ursprungliga tomheten, Ginnungagap, om universums tillkomst (kosmogoni) och skapelsen av Ask och Embla, de första människorna (antropogoni), samt om striderna mellan gudar och jättar som leder fram till undergången, Ragnarök. Snorres Edda beskriver att världen uppstod i Ginnungagap, ett svalg där hetta och frost smälte samman till jätten Ymer och kon Audhumbla. Audhumbla slickade sedan fram mannen Bure ur isen. Bures sonsöner Oden, Vile och Ve dräpte därefter Ymer och skapade världen av hans kropp.

Den övergripande mytologiska berättelsen handlar om en kosmisk maktkamp mellan gudarna och kaoskrafter. Gudarna representerade den ordnade världen, kulturen och civilisationen, som ständigt hotades av naturens krafter, representerade av jättarna och kaosmonster (till exempel Fenrisulven och Midgårdsormen). Men minst lika viktigt är Asgårds beroende av den hemliga kunskap som jättar och andra demoniska väsen besitter och de allianser, och äktenskap, som knyts mellan dessa två världar.

Snorre ger i sin Edda detaljerade upplysningar om hur universums är beskaffat: Midgård kallas människornas värld, i Asgård lever gudarna. Utgård kallas den utanförvärld där de demoniska väsendena håller till och där Jotunheim finns. Runt jorden ringlar sig Midgårdsormen, och utanför detta vidunder finns det personifierade världshavet, Ägir. I världens mitt står trädet Yggdrasil. Det symboliserar strukturen i kosmos med sina rötter i Hels underjord och grenar som sträcker sig långt upp till gudarna. Vid trädets fot ligger jätten Mimers brunn, vars vatten förmedlar kunskap om det som varit och det som komma skall. De tre nornorna Urd (det förflutna), Verdandi (det nuvarande) och Skuld (det som komma skall) och spinner ödestrådarna. Hel är namnet både på det underjordiska dödsriket och på dess härskarinna. De som fallit i strid hämtas av valkyrior och kommer till Odens Valhall eller till Freja Folkvang. I det sista slaget, Ragnarök, kommer de härskande gudarna att falla och världen kommer att gå under i en eld, varefter en ny och bättre värld kommer att uppstå ur den gamla.

Kultplatser 

Kulten under järnåldern verkar mestadels ha utövats i hemmen, men skriftliga källor, bland annat Adam av Bremen, nämner att det skall ha funnits tempelbyggnader i Norden under vikingatiden, i alla fall i Uppsala. Vid utgrävningar i Uppåkra strax söder om Lund har man funnit rester efter ett tempel som stått här i flera hundra år före nedläggningen i slutet av 900-talet. Då hela byggnadens yta kunnat grävas fram och då platsen är oskadad från senare nedgrävningar har för första gången ett fornnordiskt tempel kunnat studeras i sin helhet rent arkeologiskt.
Mycket vanligare var de så kallade "vina", heliga platser utomhus. Detta återspeglas bland annat i många av de ortnamn som innehåller efterledet -vi, som till exempel Ullevi. 2007 undersöktes ett vi från vendeltid i Lilla Ullevi fullständigt. Viet i Lilla Ullevi bestod av olika lämningar, naturliga såväl som människoskapade; centralt fanns den så kallade hargen, en stenkonstruktion som ligger på viets högsta punkt. I hargen låg en plattform som antagligen fungerat som altare. Plattformen har efterlämnat spår i form av fyra kraftiga stolphål. Söder om stenkonstruktionen fanns ett stort antal stolphål, och arkeologerna antar att det kan ha varit en offerplats på grund av de många fynd av amulettringar som man gjort där. Ringar förekom även i hargen, där man funnit närmare 70 stycken järnringar, många med mindre ringar hängande i den största ringen. Ringar antas också ha betytt mycket i den nordiska kulten då de fungerat som dörringar på kultbyggnader, vilket man sett i templet i Uppåkra, och som också är avbildat på Sparlösastenen. Det isländska sagomaterialet bekräftar också ringarnas betydelse i kulten.

Blot 

Blot är ett offer i nordisk religion som syftar till att vinna gudars eller alvers välvilja så att de uppfyller dess önskemål, som genomför blotet. Ordet är släkt med gotiskans blôtan i meningen "dyrka, tillbedja", och forntyskans bluozan, i betydelsen "offra" och "stärka". Troligen har ordet ursprungsbetydelsen "åkalla med besvärjelse eller offer". Religionsprofessor Britt-Mari Näsström härleder ordet till en indoeuropeisk rot *bhle som betyder ”svälla, vara svullen” och i överförd bemärkelse ”tillta, öka”. Det betyder att offret i sig ökar den offrandes egendom.  
Offerritualerna verkar ha skett på två sätt; antingen frambar man offret till gudarna eller så tog man del av offergåvan genom att förtära den offrade maten och drycken. Det finns flera berättelser från norra Europa om stora offerfester med mat och dryck.

De isländska sagorna talar om tre årliga blot: höstblot, midvinterblot och vårblot.

Namngivna blothögtider 
 Disablot (början av februari)
 Segerblot (vårdagjämningen)
 Midsommarblot (midsommar)
 Skördeblot (augusti–september)
 Höstblot (mitten av oktober)
 Alvablot (november/allhelgona)
 Midvinterblot (januari)

Asatron efter kristnandet 

Sedan Nordeuropa kristnats och asatron förbjudits, allra sist i Sverige, levde en del av dess trosuppfattningar vidare i folktro och i folksagor, "Prins Hatt under jorden" är till exempel ursprungligen berättelser om guden Höder. En dikt från Trollkyrka i Tiveden redogör även för hur ett hemligt offer utfördes.
Men det finns också indikationer att asatron levde kvar länge i hemlighet; under digerdödens härjningar på 1300-talet berättas det att flera områden återgick till hedendomen i försök att hejda pestens härjningar, och det finns kätterimål från 1500-talet mot svenskar som dyrkat Oden. Myten om Odens jakt, liksom föreställningar om Tor, Fröja (Freja), Locke (Loke), Frigg och så vidare visar att allmogen långt fram på 1800- och början av 1900-talet hade kunskaper om den forna religionen. Man har också visat att så kallade älvkvarnar använts för offer långt in på 1800-talet.

Andra sedvänjor som kan tolkas som rester av asatro, är till exempel riten rörande Kornguden i Vånga, som var en helgonbild i Norra Vånga i Västergötland. Helgonbilden togs ut till åkrarna för att säkerställa att skörden blev god. 1826 försökte stiftet förhindra denna sed genom att undanskaffa helgonbilden men enligt Västgöta-Bengtsson så ska Vångaborna ha gjort sig en ny Korngud. Det är dock inget ovanligt att kristen helgondyrkan tett sig på detta vis, och flera exempel finns från kontinenten varför det inte med självklarhet går att göra kopplingen till asatron.
Ebbe Schön skriver i sin bok Asa-Tors hammare om hur rester av asatron levde kvar i folksagor ännu i början av 1900-talet.

Även om de högre gudarna i asatron så småningom försvann, så levde dess mindre väsen vidare i folktrons föreställningar om älvor, vättar, och tomtar och i tron på skogsrået, näcken, havsfrun med flera in i våra dagar och gör så alltjämt på sina ställen. När bonden satte ut en skål gröt till tomten på julnatten för att denne skulle se till djuren på gården, så utförde han en rit med urgamla anor, det som på vikingatid och tidig medeltid kallades blot.

Folktrons föreställningar om avlidnas själar och naturföreteelsernas andar återfinns i liknande skepnad hos många folk, och att de hos nordbor och övriga germaner varit väsentligen de samma intygas dels av överensstämmande folktro från yngre tid, dels av de gemensamma benämningarna för älva, mara, huldra, dvärg och näck. Om de germanska folkens gudatro finns några underrättelser ända från vår tideräknings början, och ett för dessa gemensamt drag är att utom träd, floder och berg vanligen tre, ibland fyra gudar uppges ha dyrkats: Caesar anger solen, Vulcanus (elden) och månen, Tacitus anger Mercurius, Hercules och Mars. I det saxiska doplöftet från 800-talet avsvärjs "Thuner och Woden och Saxnot och alla de onda makter, som är i deras sällskap".

Modern asatro 

I slutet av 1800-talet blommade återigen ett intresse för asatron upp. En andra våg kom på 1920-talet, och en tredje kom i samband med det ökande intresset för naturreligioner under 1960-talet. I dag finns det flera organisationer som sprider kunskap om mytologin, religionen och religiösa sammankomster, huvudsakligen i Skandinavien, England och USA. Det isländska ordet ásatrú har blivit det vanligaste ordet internationellt men även Odinism (efter det isländska/fornnordiska namnet på Oden) förekommer. Nordiska Asasamfundet (NAS), det största samfundet för Asatro i Sverige använder beteckningen asatro för religionen. I Skandinavien används ibland även beteckningen forn sed för denna religion av Samfundet Forn Sed Sverige.

Forskningshistoria kring asatro 
Friedrich Max Müller (1823–1900) var en tysk språkforskare som var intresserad av möjliga förbindelse mellan språk, religion och mytologi. Müller menade att naturfenomen blev till gudar genom en missuppfattning av naturlagarna. Müllers resonemang kan spåras i flera verk från 1800-talets slut, där de nordiska gudarna kom att förklaras som naturfenomen. Inom mytforskning kallas detta för den naturmytologiska skolan. Från 1800-talets slut fick den naturmytologiska skolan kritik. Norske Sophus Bugge (1833–1907) och tyske Eugen Mogk kom att representera en ny källkritisk riktning i forskningen och menade att de nordiska myterna först och främst var en produkt Nordens möte med kristendomen. I Bugges huvudverk, De nordiske Gude- og Heltesagns Oprindelse, menade han att den nordiska mytologin hade skapats i möte med kristendomens texter och litterära traditioner. Han menade vidare att asatron hade inspirerats av keltiska och anglosaxiska traditioner med lån från grekisk och romersk mytologi. På 2000-talet har Bugges teori ingen stark ställning. Gro Steinsland menar dock att Bugges forskning "banade väg för den källkritiska debatten som uppstod och som fortfarande förs". Bugges kommenterade utgåva av Den eldre Edda (1867) betraktas fortfarande som ett standardverk för de som arbetar källkritiskt med eddadikterna.

Källtexter 
Följande texter och föremål utgör historiska källor till kunskap om den nordiska mytologins innehåll, som de i olika utsträckning nämner och behandlar:

 Tacitus: Germania (ca 98 e.kr.)
 Snorre Sturlason:
 Codex Regius (”Kungliga boken”) eller Poetiska Eddan (ca 800 e.kr.)
 Prosaiska Eddan  (ca 1200 e.kr.)
 Saxo Grammaticus: Gesta Danorum (ca 1200 e.kr.)
 Runstenar
 Beowulfskvädet
 Tjodolf av Hvin:
 Ynglingasagan
 Haustlong
 Eilif Gudrunarson: Thórsdrápa
 Adam av Bremen: Gesta Hammaburgensis ecclesiae pontificum

Referenser

<a id="top"></a>
# Test fixtures

**Contents**<br>
[Non-Templated test fixtures](#non-templated-test-fixtures)<br>
[Templated test fixtures](#templated-test-fixtures)<br>
[Signature-based parameterised test fixtures](#signature-based-parameterised-test-fixtures)<br>
[Template fixtures with types specified in template type lists](#template-fixtures-with-types-specified-in-template-type-lists)<br>

## Non-Templated test fixtures

Although Catch2 allows you to group tests together as 
[sections within a test case](test-cases-and-sections.md), it can still 
be convenient, sometimes, to group them using a more traditional test. 
Catch2 fully supports this too with 3 different macros for 
non-templated test fixtures. They are: 

| Macro    | Description |
|----------|-------------|
|1. `TEST_CASE_METHOD(className, ...)`| Creates a uniquely named class which inherits from the class specified by `className`. The test function will be a member of this derived class. An instance of the derived class will be created for every partial run of the test case. |
|2. `METHOD_AS_TEST_CASE(member-function, ...)`| Uses `member-function` as the test function. An instance of the class will be created for each partial run of the test case. |
|3. `TEST_CASE_PERSISTENT_FIXTURE(className, ...)`| Creates a uniquely named class which inherits from the class specified by `className`. The test function will be a member of this derived class. An instance of the derived class will be created at the start of the test run. That instance will be destroyed once the entire test case has ended. |

### 1. `TEST_CASE_METHOD`


You define a `TEST_CASE_METHOD` test fixture as a simple structure:

```c++
class UniqueTestsFixture {
  private:
   static int uniqueID;
  protected:
   DBConnection conn;
  public:
   UniqueTestsFixture() : conn(DBConnection::createConnection("myDB")) {
   }
  protected:
   int getID() {
     return ++uniqueID;
   }
 };

 int UniqueTestsFixture::uniqueID = 0;

 TEST_CASE_METHOD(UniqueTestsFixture, "Create Employee/No Name", "[create]") {
   REQUIRE_THROWS(conn.executeSQL("INSERT INTO employee (id, name) VALUES (?, ?)", getID(), ""));
 }
 TEST_CASE_METHOD(UniqueTestsFixture, "Create Employee/Normal", "[create]") {
   REQUIRE(conn.executeSQL("INSERT INTO employee (id, name) VALUES (?, ?)", getID(), "Joe Bloggs"));
 }
```

The two test cases here will create uniquely-named derived classes of 
UniqueTestsFixture and thus can access the `getID()` protected method 
and `conn` member variables. This ensures that both the test cases 
are able to create a DBConnection using the same method 
(DRY principle) and that any ID's created are unique such that the 
order that tests are executed does not matter. 

### 2. `METHOD_AS_TEST_CASE`

`METHOD_AS_TEST_CASE` lets you register a member function of a class 
as a Catch2 test case. The class will be separately instantiated 
for each method registered in this way.

```cpp
class TestClass {
    std::string s;

public:
    TestClass()
        :s( "hello" )
    {}

    void testCase() {
        REQUIRE( s == "hello" );
    }
};


METHOD_AS_TEST_CASE( TestClass::testCase, "Use class's method as a test case", "[class]" )
```

This type of fixture is similar to [TEST_CASE_METHOD](#1-test_case_method) except in this 
case it will directly use the provided class to create an object rather than a derived 
class.

### 3. `TEST_CASE_PERSISTENT_FIXTURE`

> [Introduced](https://github.com/catchorg/Catch2/pull/2885) in Catch2 3.7.0

`TEST_CASE_PERSISTENT_FIXTURE` behaves in the same way as
[TEST_CASE_METHOD](#1-test_case_method) except that there will only be
one instance created throughout the entire run of a test case. To 
demonstrate this have a look at the following example:

```cpp
class ClassWithExpensiveSetup {
public:
    ClassWithExpensiveSetup() {
        // expensive construction
        std::this_thread::sleep_for( std::chrono::seconds( 2 ) );
    }

    ~ClassWithExpensiveSetup() noexcept {
        // expensive destruction
        std::this_thread::sleep_for( std::chrono::seconds( 1 ) );
    }

    int getInt() const { return 42; }
};

struct MyFixture {
    mutable int myInt = 0;
    ClassWithExpensiveSetup expensive;
};

TEST_CASE_PERSISTENT_FIXTURE( MyFixture, "Tests with MyFixture" ) {

    const int val = myInt++;

    SECTION( "First partial run" ) {
        const auto otherValue = expensive.getInt();
        REQUIRE( val == 0 );
        REQUIRE( otherValue == 42 );
    }

    SECTION( "Second partial run" ) { REQUIRE( val == 1 ); }
}
```

This example demonstrates two possible use-cases of this fixture type:
1. Improve test run times by reducing the amount of expensive and 
redundant setup and tear-down required.
2. Reusing results from the previous partial run, in the current
partial run.

This test case will be executed twice as there are two leaf sections.
On the first run `val` will be `0` and on the second run `val` will be 
`1`. This demonstrates that we were able to use the results of the
previous partial run in subsequent partial runs.

Additionally, we are simulating an expensive object using 
`std::this_thread::sleep_for`, but real world use-cases could be:
1. Creating a D3D12/Vulkan device
2. Connecting to a database
3. Loading a file.

The fixture object (`MyFixture`) will be constructed just before the
test case begins, and it will be destroyed just after the test case 
ends. Therefore, this expensive object will only be created and 
destroyed once during the execution of this test case. If we had used 
`TEST_CASE_METHOD`, `MyFixture` would have been created and destroyed 
twice during the execution of this test case.

NOTE: The member function which runs the test case is `const`. Therefore 
if you want to mutate any member of the fixture it must be marked as
`mutable` as shown in this example. This is to make it clear that
the initial state of the fixture is intended to mutate during the
execution of the test case.

## Templated test fixtures

Catch2 also provides `TEMPLATE_TEST_CASE_METHOD` and
`TEMPLATE_PRODUCT_TEST_CASE_METHOD` that can be used together
with templated fixtures and templated template fixtures to perform
tests for multiple different types. Unlike `TEST_CASE_METHOD`,
`TEMPLATE_TEST_CASE_METHOD` and `TEMPLATE_PRODUCT_TEST_CASE_METHOD` do
require the tag specification to be non-empty, as it is followed by
further macro arguments.

Also note that, because of limitations of the C++ preprocessor, if you
want to specify a type with multiple template parameters, you need to
enclose it in parentheses, e.g. `std::map<int, std::string>` needs to be
passed as `(std::map<int, std::string>)`.
In the case of `TEMPLATE_PRODUCT_TEST_CASE_METHOD`, if a member of the
type list should consist of more than single type, it needs to be enclosed
in another pair of parentheses, e.g. `(std::map, std::pair)` and
`((int, float), (char, double))`.

Example:
```cpp
template< typename T >
struct Template_Fixture {
    Template_Fixture(): m_a(1) {}

    T m_a;
};

TEMPLATE_TEST_CASE_METHOD(Template_Fixture,
                          "A TEMPLATE_TEST_CASE_METHOD based test run that succeeds",
                          "[class][template]",
                          int, float, double) {
    REQUIRE( Template_Fixture<TestType>::m_a == 1 );
}

template<typename T>
struct Template_Template_Fixture {
    Template_Template_Fixture() {}

    T m_a;
};

template<typename T>
struct Foo_class {
    size_t size() {
        return 0;
    }
};

TEMPLATE_PRODUCT_TEST_CASE_METHOD(Template_Template_Fixture,
                                  "A TEMPLATE_PRODUCT_TEST_CASE_METHOD based test succeeds",
                                  "[class][template]",
                                  (Foo_class, std::vector),
                                  int) {
    REQUIRE( Template_Template_Fixture<TestType>::m_a.size() == 0 );
}
```

_While there is an upper limit on the number of types you can specify
in single `TEMPLATE_TEST_CASE_METHOD` or `TEMPLATE_PRODUCT_TEST_CASE_METHOD`,
the limit is very high and should not be encountered in practice._

## Signature-based parameterised test fixtures

> [Introduced](https://github.com/catchorg/Catch2/issues/1609) in Catch2 2.8.0.

Catch2 also provides `TEMPLATE_TEST_CASE_METHOD_SIG` and `TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG` to support
fixtures using non-type template parameters. These test cases work similar to `TEMPLATE_TEST_CASE_METHOD` and `TEMPLATE_PRODUCT_TEST_CASE_METHOD`,
with additional positional argument for [signature](test-cases-and-sections.md#signature-based-parametrised-test-cases).

Example:
```cpp
template <int V>
struct Nttp_Fixture{
    int value = V;
};

TEMPLATE_TEST_CASE_METHOD_SIG(
    Nttp_Fixture,
    "A TEMPLATE_TEST_CASE_METHOD_SIG based test run that succeeds",
    "[class][template][nttp]",
    ((int V), V),
    1, 3, 6) {
    REQUIRE(Nttp_Fixture<V>::value > 0);
}

template<typename T>
struct Template_Fixture_2 {
    Template_Fixture_2() {}

    T m_a;
};

template< typename T, size_t V>
struct Template_Foo_2 {
    size_t size() { return V; }
};

TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG(
    Template_Fixture_2,
    "A TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG based test run that succeeds",
    "[class][template][product][nttp]",
    ((typename T, size_t S), T, S),
    (std::array, Template_Foo_2),
    ((int,2), (float,6))) {
    REQUIRE(Template_Fixture_2<TestType>{}.m_a.size() >= 2);
}
```

## Template fixtures with types specified in template type lists

Catch2 also provides `TEMPLATE_LIST_TEST_CASE_METHOD` to support template fixtures with types specified in
template type lists like `std::tuple`, `boost::mpl::list` or `boost::mp11::mp_list`. This test case works the same as `TEMPLATE_TEST_CASE_METHOD`,
only difference is the source of types. This allows you to reuse the template type list in multiple test cases.

Example:
```cpp
using MyTypes = std::tuple<int, char, double>;
TEMPLATE_LIST_TEST_CASE_METHOD(Template_Fixture,
                               "Template test case method with test types specified inside std::tuple",
                               "[class][template][list]",
                               MyTypes) {
    REQUIRE( Template_Fixture<TestType>::m_a == 1 );
}
```

---

[Home](Readme.md#top)

// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.

//! A lightweight logging facade.
//!
//! The `log` crate provides a single logging API that abstracts over the
//! actual logging implementation. Libraries can use the logging API provided
//! by this crate, and the consumer of those libraries can choose the logging
//! implementation that is most suitable for its use case.
//!
//! If no logging implementation is selected, the facade falls back to a "noop"
//! implementation that ignores all log messages. The overhead in this case
//! is very small - just an integer load, comparison and jump.
//!
//! A log request consists of a _target_, a _level_, and a _body_. A target is a
//! string which defaults to the module path of the location of the log request,
//! though that default may be overridden. Logger implementations typically use
//! the target to filter requests based on some user configuration.
//!
//! # Usage
//!
//! The basic use of the log crate is through the five logging macros: [`error!`],
//! [`warn!`], [`info!`], [`debug!`] and [`trace!`]
//! where `error!` represents the highest-priority log messages
//! and `trace!` the lowest. The log messages are filtered by configuring
//! the log level to exclude messages with a lower priority.
//! Each of these macros accept format strings similarly to [`println!`].
//!
//!
//! [`error!`]: ./macro.error.html
//! [`warn!`]: ./macro.warn.html
//! [`info!`]: ./macro.info.html
//! [`debug!`]: ./macro.debug.html
//! [`trace!`]: ./macro.trace.html
//! [`println!`]: https://doc.rust-lang.org/stable/std/macro.println.html
//!
//! Avoid writing expressions with side-effects in log statements. They may not be evaluated.
//!
//! ## In libraries
//!
//! Libraries should link only to the `log` crate, and use the provided
//! macros to log whatever information will be useful to downstream consumers.
//!
//! ### Examples
//!
//! ```
//! # #[derive(Debug)] pub struct Yak(String);
//! # impl Yak { fn shave(&mut self, _: u32) {} }
//! # fn find_a_razor() -> Result<u32, u32> { Ok(1) }
//! use log::{info, warn};
//!
//! pub fn shave_the_yak(yak: &mut Yak) {
//!     info!(target: "yak_events", "Commencing yak shaving for {yak:?}");
//!
//!     loop {
//!         match find_a_razor() {
//!             Ok(razor) => {
//!                 info!("Razor located: {razor}");
//!                 yak.shave(razor);
//!                 break;
//!             }
//!             Err(err) => {
//!                 warn!("Unable to locate a razor: {err}, retrying");
//!             }
//!         }
//!     }
//! }
//! # fn main() {}
//! ```
//!
//! ## In executables
//!
//! Executables should choose a logging implementation and initialize it early in the
//! runtime of the program. Logging implementations will typically include a
//! function to do this. Any log messages generated before
//! the implementation is initialized will be ignored.
//!
//! The executable itself may use the `log` crate to log as well.
//!
//! ### Warning
//!
//! The logging system may only be initialized once.
//!
//! ## Structured logging
//!
//! If you enable the `kv` feature you can associate structured values
//! with your log records. If we take the example from before, we can include
//! some additional context besides what's in the formatted message:
//!
//! ```
//! # use serde::Serialize;
//! # #[derive(Debug, Serialize)] pub struct Yak(String);
//! # impl Yak { fn shave(&mut self, _: u32) {} }
//! # fn find_a_razor() -> Result<u32, std::io::Error> { Ok(1) }
//! # #[cfg(feature = "kv_serde")]
//! # fn main() {
//! use log::{info, warn};
//!
//! pub fn shave_the_yak(yak: &mut Yak) {
//!     info!(target: "yak_events", yak:serde; "Commencing yak shaving");
//!
//!     loop {
//!         match find_a_razor() {
//!             Ok(razor) => {
//!                 info!(razor; "Razor located");
//!                 yak.shave(razor);
//!                 break;
//!             }
//!             Err(e) => {
//!                 warn!(e:err; "Unable to locate a razor, retrying");
//!             }
//!         }
//!     }
//! }
//! # }
//! # #[cfg(not(feature = "kv_serde"))]
//! # fn main() {}
//! ```
//!
//! See the [`kv`] module documentation for more details.
//!
//! # Available logging implementations
//!
//! In order to produce log output executables have to use
//! a logger implementation compatible with the facade.
//! There are many available implementations to choose from,
//! here are some of the most popular ones:
//!
//! * Simple minimal loggers:
//!     * [env_logger]
//!     * [colog]
//!     * [simple_logger]
//!     * [simplelog]
//!     * [pretty_env_logger]
//!     * [stderrlog]
//!     * [flexi_logger]
//!     * [call_logger]
//!     * [std-logger]
//!     * [structured-logger]
//!     * [clang_log]
//!     * [ftail]
//! * Complex configurable frameworks:
//!     * [log4rs]
//!     * [logforth]
//!     * [fern]
//!     * [spdlog-rs]
//! * Adaptors for other facilities:
//!     * [syslog]
//!     * [slog-stdlog]
//!     * [systemd-journal-logger]
//!     * [android_log]
//!     * [win_dbg_logger]
//!     * [db_logger]
//!     * [log-to-defmt]
//!     * [logcontrol-log]
//! * For WebAssembly binaries:
//!     * [console_log]
//! * For dynamic libraries:
//!     * You may need to construct an FFI-safe wrapper over `log` to initialize in your libraries
//! * Utilities:
//!     * [log_err]
//!     * [log-reload]
//!     * [alterable_logger]
//!
//! # Implementing a Logger
//!
//! Loggers implement the [`Log`] trait. Here's a very basic example that simply
//! logs all messages at the [`Error`][level_link], [`Warn`][level_link] or
//! [`Info`][level_link] levels to stdout:
//!
//! ```
//! use log::{Record, Level, Metadata};
//!
//! struct SimpleLogger;
//!
//! impl log::Log for SimpleLogger {
//!     fn enabled(&self, metadata: &Metadata) -> bool {
//!         metadata.level() <= Level::Info
//!     }
//!
//!     fn log(&self, record: &Record) {
//!         if self.enabled(record.metadata()) {
//!             println!("{} - {}", record.level(), record.args());
//!         }
//!     }
//!
//!     fn flush(&self) {}
//! }
//!
//! # fn main() {}
//! ```
//!
//! Loggers are installed by calling the [`set_logger`] function. The maximum
//! log level also needs to be adjusted via the [`set_max_level`] function. The
//! logging facade uses this as an optimization to improve performance of log
//! messages at levels that are disabled. It's important to set it, as it
//! defaults to [`Off`][filter_link], so no log messages will ever be captured!
//! In the case of our example logger, we'll want to set the maximum log level
//! to [`Info`][filter_link], since we ignore any [`Debug`][level_link] or
//! [`Trace`][level_link] level log messages. A logging implementation should
//! provide a function that wraps a call to [`set_logger`] and
//! [`set_max_level`], handling initialization of the logger:
//!
//! ```
//! # use log::{Level, Metadata};
//! # struct SimpleLogger;
//! # impl log::Log for SimpleLogger {
//! #   fn enabled(&self, _: &Metadata) -> bool { false }
//! #   fn log(&self, _: &log::Record) {}
//! #   fn flush(&self) {}
//! # }
//! # fn main() {}
//! use log::{SetLoggerError, LevelFilter};
//!
//! static LOGGER: SimpleLogger = SimpleLogger;
//!
//! pub fn init() -> Result<(), SetLoggerError> {
//!     log::set_logger(&LOGGER)
//!         .map(|()| log::set_max_level(LevelFilter::Info))
//! }
//! ```
//!
//! Implementations that adjust their configurations at runtime should take care
//! to adjust the maximum log level as well.
//!
//! # Use with `std`
//!
//! `set_logger` requires you to provide a `&'static Log`, which can be hard to
//! obtain if your logger depends on some runtime configuration. The
//! `set_boxed_logger` function is available with the `std` Cargo feature. It is
//! identical to `set_logger` except that it takes a `Box<Log>` rather than a
//! `&'static Log`:
//!
//! ```
//! # use log::{Level, LevelFilter, Log, SetLoggerError, Metadata};
//! # struct SimpleLogger;
//! # impl log::Log for SimpleLogger {
//! #   fn enabled(&self, _: &Metadata) -> bool { false }
//! #   fn log(&self, _: &log::Record) {}
//! #   fn flush(&self) {}
//! # }
//! # fn main() {}
//! # #[cfg(feature = "std")]
//! pub fn init() -> Result<(), SetLoggerError> {
//!     log::set_boxed_logger(Box::new(SimpleLogger))
//!         .map(|()| log::set_max_level(LevelFilter::Info))
//! }
//! ```
//!
//! # Compile time filters
//!
//! Log levels can be statically disabled at compile time by enabling one of these Cargo features:
//!
//! * `max_level_off`
//! * `max_level_error`
//! * `max_level_warn`
//! * `max_level_info`
//! * `max_level_debug`
//! * `max_level_trace`
//!
//! Log invocations at disabled levels will be skipped and will not even be present in the
//! resulting binary. These features control the value of the `STATIC_MAX_LEVEL` constant. The
//! logging macros check this value before logging a message. By default, no levels are disabled.
//!
//! It is possible to override this level for release builds only with the following features:
//!
//! * `release_max_level_off`
//! * `release_max_level_error`
//! * `release_max_level_warn`
//! * `release_max_level_info`
//! * `release_max_level_debug`
//! * `release_max_level_trace`
//!
//! Libraries should avoid using the max level features because they're global and can't be changed
//! once they're set.
//!
//! For example, a crate can disable trace level logs in debug builds and trace, debug, and info
//! level logs in release builds with the following configuration:
//!
//! ```toml
//! [dependencies]
//! log = { version = "0.4", features = ["max_level_debug", "release_max_level_warn"] }
//! ```
//! # Crate Feature Flags
//!
//! The following crate feature flags are available in addition to the filters. They are
//! configured in your `Cargo.toml`.
//!
//! * `std` allows use of `std` crate instead of the default `core`. Enables using `std::error` and
//!   `set_boxed_logger` functionality.
//! * `serde` enables support for serialization and deserialization of `Level` and `LevelFilter`.
//!
//! ```toml
//! [dependencies]
//! log = { version = "0.4", features = ["std", "serde"] }
//! ```
//!
//! # Version compatibility
//!
//! The 0.3 and 0.4 versions of the `log` crate are almost entirely compatible. Log messages
//! made using `log` 0.3 will forward transparently to a logger implementation using `log` 0.4. Log
//! messages made using `log` 0.4 will forward to a logger implementation using `log` 0.3, but the
//! module path and file name information associated with the message will unfortunately be lost.
//!
//! [`Log`]: trait.Log.html
//! [level_link]: enum.Level.html
//! [filter_link]: enum.LevelFilter.html
//! [`set_logger`]: fn.set_logger.html
//! [`set_max_level`]: fn.set_max_level.html
//! [`try_set_logger_raw`]: fn.try_set_logger_raw.html
//! [`shutdown_logger_raw`]: fn.shutdown_logger_raw.html
//! [env_logger]: https://docs.rs/env_logger/*/env_logger/
//! [colog]: https://docs.rs/colog/*/colog/
//! [simple_logger]: https://github.com/borntyping/rust-simple_logger
//! [simplelog]: https://github.com/drakulix/simplelog.rs
//! [pretty_env_logger]: https://docs.rs/pretty_env_logger/*/pretty_env_logger/
//! [stderrlog]: https://docs.rs/stderrlog/*/stderrlog/
//! [flexi_logger]: https://docs.rs/flexi_logger/*/flexi_logger/
//! [call_logger]: https://docs.rs/call_logger/*/call_logger/
//! [std-logger]: https://docs.rs/std-logger/*/std_logger/
//! [syslog]: https://docs.rs/syslog/*/syslog/
//! [slog-stdlog]: https://docs.rs/slog-stdlog/*/slog_stdlog/
//! [log4rs]: https://docs.rs/log4rs/*/log4rs/
//! [logforth]: https://docs.rs/logforth/*/logforth/
//! [fern]: https://docs.rs/fern/*/fern/
//! [spdlog-rs]: https://docs.rs/spdlog-rs/*/spdlog/
//! [systemd-journal-logger]: https://docs.rs/systemd-journal-logger/*/systemd_journal_logger/
//! [android_log]: https://docs.rs/android_log/*/android_log/
//! [win_dbg_logger]: https://docs.rs/win_dbg_logger/*/win_dbg_logger/
//! [db_logger]: https://docs.rs/db_logger/*/db_logger/
//! [log-to-defmt]: https://docs.rs/log-to-defmt/*/log_to_defmt/
//! [console_log]: https://docs.rs/console_log/*/console_log/
//! [structured-logger]: https://docs.rs/structured-logger/latest/structured_logger/
//! [logcontrol-log]: https://docs.rs/logcontrol-log/*/logcontrol_log/
//! [log_err]: https://docs.rs/log_err/*/log_err/
//! [log-reload]: https://docs.rs/log-reload/*/log_reload/
//! [alterable_logger]: https://docs.rs/alterable_logger/*/alterable_logger
//! [clang_log]: https://docs.rs/clang_log/latest/clang_log
//! [ftail]: https://docs.rs/ftail/latest/ftail

#![doc(
    html_logo_url = "https://prev.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
    html_favicon_url = "https://prev.rust-lang.org/favicon.ico",
    html_root_url = "https://docs.rs/log/0.4.33"
)]
#![warn(missing_docs)]
#![deny(missing_debug_implementations, unconditional_recursion)]
#![cfg_attr(all(not(feature = "std"), not(test)), no_std)]

#[cfg(any(
    all(feature = "max_level_off", feature = "max_level_error"),
    all(feature = "max_level_off", feature = "max_level_warn"),
    all(feature = "max_level_off", feature = "max_level_info"),
    all(feature = "max_level_off", feature = "max_level_debug"),
    all(feature = "max_level_off", feature = "max_level_trace"),
    all(feature = "max_level_error", feature = "max_level_warn"),
    all(feature = "max_level_error", feature = "max_level_info"),
    all(feature = "max_level_error", feature = "max_level_debug"),
    all(feature = "max_level_error", feature = "max_level_trace"),
    all(feature = "max_level_warn", feature = "max_level_info"),
    all(feature = "max_level_warn", feature = "max_level_debug"),
    all(feature = "max_level_warn", feature = "max_level_trace"),
    all(feature = "max_level_info", feature = "max_level_debug"),
    all(feature = "max_level_info", feature = "max_level_trace"),
    all(feature = "max_level_debug", feature = "max_level_trace"),
))]
compile_error!("multiple max_level_* features set");

#[rustfmt::skip]
#[cfg(any(
    all(feature = "release_max_level_off", feature = "release_max_level_error"),
    all(feature = "release_max_level_off", feature = "release_max_level_warn"),
    all(feature = "release_max_level_off", feature = "release_max_level_info"),
    all(feature = "release_max_level_off", feature = "release_max_level_debug"),
    all(feature = "release_max_level_off", feature = "release_max_level_trace"),
    all(feature = "release_max_level_error", feature = "release_max_level_warn"),
    all(feature = "release_max_level_error", feature = "release_max_level_info"),
    all(feature = "release_max_level_error", feature = "release_max_level_debug"),
    all(feature = "release_max_level_error", feature = "release_max_level_trace"),
    all(feature = "release_max_level_warn", feature = "release_max_level_info"),
    all(feature = "release_max_level_warn", feature = "release_max_level_debug"),
    all(feature = "release_max_level_warn", feature = "release_max_level_trace"),
    all(feature = "release_max_level_info", feature = "release_max_level_debug"),
    all(feature = "release_max_level_info", feature = "release_max_level_trace"),
    all(feature = "release_max_level_debug", feature = "release_max_level_trace"),
))]
compile_error!("multiple release_max_level_* features set");

#[cfg(all(not(feature = "std"), not(test)))]
extern crate core as std;

use std::cfg;
#[cfg(feature = "std")]
use std::error;
use std::str::FromStr;
use std::{cmp, fmt, mem};

#[macro_use]
mod macros;
mod serde;

#[cfg(feature = "kv")]
pub mod kv;

#[cfg(target_has_atomic = "ptr")]
use std::sync::atomic::{AtomicUsize, Ordering};

#[cfg(not(target_has_atomic = "ptr"))]
use std::cell::Cell;
#[cfg(not(target_has_atomic = "ptr"))]
use std::sync::atomic::Ordering;

#[cfg(not(target_has_atomic = "ptr"))]
struct AtomicUsize {
    v: Cell<usize>,
}

#[cfg(not(target_has_atomic = "ptr"))]
impl AtomicUsize {
    const fn new(v: usize) -> AtomicUsize {
        AtomicUsize { v: Cell::new(v) }
    }

    fn load(&self, _order: Ordering) -> usize {
        self.v.get()
    }

    fn store(&self, val: usize, _order: Ordering) {
        self.v.set(val)
    }
}

// Any platform without atomics is unlikely to have multiple cores, so
// writing via Cell will not be a race condition.
#[cfg(not(target_has_atomic = "ptr"))]
unsafe impl Sync for AtomicUsize {}

// The LOGGER static holds a pointer to the global logger. It is protected by
// the STATE static which determines whether LOGGER has been initialized yet.
static mut LOGGER: &dyn Log = &NopLogger;

static STATE: AtomicUsize = AtomicUsize::new(0);

// There are three different states that we care about: the logger's
// uninitialized, the logger's initializing (set_logger's been called but
// LOGGER hasn't actually been set yet), or the logger's active.
const UNINITIALIZED: usize = 0;
const INITIALIZING: usize = 1;
const INITIALIZED: usize = 2;

static MAX_LOG_LEVEL_FILTER: AtomicUsize = AtomicUsize::new(0);

static LOG_LEVEL_NAMES: [&str; 6] = ["OFF", "ERROR", "WARN", "INFO", "DEBUG", "TRACE"];

static SET_LOGGER_ERROR: &str = "attempted to set a logger after the logging system \
                                 was already initialized";
static LEVEL_PARSE_ERROR: &str =
    "attempted to convert a string that doesn't match an existing log level";

/// An enum representing the available verbosity levels of the logger.
///
/// Typical usage includes: checking if a certain `Level` is enabled with
/// [`log_enabled!`](macro.log_enabled.html), specifying the `Level` of
/// [`log!`](macro.log.html), and comparing a `Level` directly to a
/// [`LevelFilter`](enum.LevelFilter.html).
#[repr(usize)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
pub enum Level {
    /// The "error" level.
    ///
    /// Designates very serious errors.
    // This way these line up with the discriminants for LevelFilter below
    // This works because Rust treats field-less enums the same way as C does:
    // https://doc.rust-lang.org/reference/items/enumerations.html#custom-discriminant-values-for-field-less-enumerations
    Error = 1,
    /// The "warn" level.
    ///
    /// Designates hazardous situations.
    Warn,
    /// The "info" level.
    ///
    /// Designates useful information.
    Info,
    /// The "debug" level.
    ///
    /// Designates lower priority information.
    Debug,
    /// The "trace" level.
    ///
    /// Designates very low priority, often extremely verbose, information.
    Trace,
}

impl PartialEq<LevelFilter> for Level {
    #[inline]
    fn eq(&self, other: &LevelFilter) -> bool {
        *self as usize == *other as usize
    }
}

impl PartialOrd<LevelFilter> for Level {
    #[inline]
    fn partial_cmp(&self, other: &LevelFilter) -> Option<cmp::Ordering> {
        Some((*self as usize).cmp(&(*other as usize)))
    }
}

impl FromStr for Level {
    type Err = ParseLevelError;
    fn from_str(level: &str) -> Result<Level, Self::Err> {
        // iterate from 1, excluding "OFF"
        for idx in 1..LOG_LEVEL_NAMES.len() {
            if LOG_LEVEL_NAMES[idx].eq_ignore_ascii_case(level) {
                return Ok(Level::from_usize(idx).unwrap());
            }
        }
        Err(ParseLevelError(()))
    }
}

impl fmt::Display for Level {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.pad(self.as_str())
    }
}

impl Level {
    fn from_usize(u: usize) -> Option<Level> {
        match u {
            1 => Some(Level::Error),
            2 => Some(Level::Warn),
            3 => Some(Level::Info),
            4 => Some(Level::Debug),
            5 => Some(Level::Trace),
            _ => None,
        }
    }

    /// Returns the most verbose logging level.
    #[inline]
    pub fn max() -> Level {
        Level::Trace
    }

    /// Converts the `Level` to the equivalent `LevelFilter`.
    #[inline]
    pub fn to_level_filter(&self) -> LevelFilter {
        LevelFilter::from_usize(*self as usize).unwrap()
    }

    /// Returns the string representation of the `Level`.
    ///
    /// This returns the same string as the `fmt::Display` implementation.
    pub fn as_str(&self) -> &'static str {
        LOG_LEVEL_NAMES[*self as usize]
    }

    /// Iterate through all supported logging levels.
    ///
    /// The order of iteration is from more severe to less severe log messages.
    ///
    /// # Examples
    ///
    /// ```
    /// use log::Level;
    ///
    /// let mut levels = Level::iter();
    ///
    /// assert_eq!(Some(Level::Error), levels.next());
    /// assert_eq!(Some(Level::Trace), levels.last());
    /// ```
    pub fn iter() -> impl Iterator<Item = Self> {
        (1..6).map(|i| Self::from_usize(i).unwrap())
    }

    /// Get the next-highest `Level` from this one.
    ///
    /// If the current `Level` is at the highest level, the returned `Level` will be the same as the
    /// current one.
    ///
    /// # Examples
    ///
    /// ```
    /// use log::Level;
    ///
    /// let level = Level::Info;
    ///
    /// assert_eq!(Level::Debug, level.increment_severity());
    /// assert_eq!(Level::Trace, level.increment_severity().increment_severity());
    /// assert_eq!(Level::Trace, level.increment_severity().increment_severity().increment_severity()); // max level
    /// ```
    pub fn increment_severity(&self) -> Self {
        let current = *self as usize;
        Self::from_usize(current + 1).unwrap_or(*self)
    }

    /// Get the next-lowest `Level` from this one.
    ///
    /// If the current `Level` is at the lowest level, the returned `Level` will be the same as the
    /// current one.
    ///
    /// # Examples
    ///
    /// ```
    /// use log::Level;
    ///
    /// let level = Level::Info;
    ///
    /// assert_eq!(Level::Warn, level.decrement_severity());
    /// assert_eq!(Level::Error, level.decrement_severity().decrement_severity());
    /// assert_eq!(Level::Error, level.decrement_severity().decrement_severity().decrement_severity()); // min level
    /// ```
    pub fn decrement_severity(&self) -> Self {
        let current = *self as usize;
        Self::from_usize(current.saturating_sub(1)).unwrap_or(*self)
    }
}

/// An enum representing the available verbosity level filters of the logger.
///
/// A `LevelFilter` may be compared directly to a [`Level`]. Use this type
/// to get and set the maximum log level with [`max_level()`] and [`set_max_level`].
///
/// [`Level`]: enum.Level.html
/// [`max_level()`]: fn.max_level.html
/// [`set_max_level`]: fn.set_max_level.html
#[repr(usize)]
#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Debug, Hash)]
pub enum LevelFilter {
    /// A level lower than all log levels.
    Off,
    /// Corresponds to the `Error` log level.
    Error,
    /// Corresponds to the `Warn` log level.
    Warn,
    /// Corresponds to the `Info` log level.
    Info,
    /// Corresponds to the `Debug` log level.
    Debug,
    /// Corresponds to the `Trace` log level.
    Trace,
}

impl PartialEq<Level> for LevelFilter {
    #[inline]
    fn eq(&self, other: &Level) -> bool {
        other.eq(self)
    }
}

impl PartialOrd<Level> for LevelFilter {
    #[inline]
    fn partial_cmp(&self, other: &Level) -> Option<cmp::Ordering> {
        Some((*self as usize).cmp(&(*other as usize)))
    }
}

impl FromStr for LevelFilter {
    type Err = ParseLevelError;
    fn from_str(level: &str) -> Result<LevelFilter, Self::Err> {
        // iterate from 0, including "OFF"
        for idx in 0..LOG_LEVEL_NAMES.len() {
            if LOG_LEVEL_NAMES[idx].eq_ignore_ascii_case(level) {
                return Ok(LevelFilter::from_usize(idx).unwrap());
            }
        }
        Err(ParseLevelError(()))
    }
}

impl fmt::Display for LevelFilter {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.pad(self.as_str())
    }
}

impl LevelFilter {
    fn from_usize(u: usize) -> Option<LevelFilter> {
        match u {
            0 => Some(LevelFilter::Off),
            1 => Some(LevelFilter::Error),
            2 => Some(LevelFilter::Warn),
            3 => Some(LevelFilter::Info),
            4 => Some(LevelFilter::Debug),
            5 => Some(LevelFilter::Trace),
            _ => None,
        }
    }

    /// Returns the most verbose logging level filter.
    #[inline]
    pub fn max() -> LevelFilter {
        LevelFilter::Trace
    }

    /// Converts `self` to the equivalent `Level`.
    ///
    /// Returns `None` if `self` is `LevelFilter::Off`.
    #[inline]
    pub fn to_level(&self) -> Option<Level> {
        Level::from_usize(*self as usize)
    }

    /// Returns the string representation of the `LevelFilter`.
    ///
    /// This returns the same string as the `fmt::Display` implementation.
    pub fn as_str(&self) -> &'static str {
        LOG_LEVEL_NAMES[*self as usize]
    }

    /// Iterate through all supported filtering levels.
    ///
    /// The order of iteration is from less to more verbose filtering.
    ///
    /// # Examples
    ///
    /// ```
    /// use log::LevelFilter;
    ///
    /// let mut levels = LevelFilter::iter();
    ///
    /// assert_eq!(Some(LevelFilter::Off), levels.next());
    /// assert_eq!(Some(LevelFilter::Trace), levels.last());
    /// ```
    pub fn iter() -> impl Iterator<Item = Self> {
        (0..6).map(|i| Self::from_usize(i).unwrap())
    }

    /// Get the next-highest `LevelFilter` from this one.
    ///
    /// If the current `LevelFilter` is at the highest level, the returned `LevelFilter` will be the
    /// same as the current one.
    ///
    /// # Examples
    ///
    /// ```
    /// use log::LevelFilter;
    ///
    /// let level_filter = LevelFilter::Info;
    ///
    /// assert_eq!(LevelFilter::Debug, level_filter.increment_severity());
    /// assert_eq!(LevelFilter::Trace, level_filter.increment_severity().increment_severity());
    /// assert_eq!(LevelFilter::Trace, level_filter.increment_severity().increment_severity().increment_severity()); // max level
    /// ```
    pub fn increment_severity(&self) -> Self {
        let current = *self as usize;
        Self::from_usize(current + 1).unwrap_or(*self)
    }

    /// Get the next-lowest `LevelFilter` from this one.
    ///
    /// If the current `LevelFilter` is at the lowest level, the returned `LevelFilter` will be the
    /// same as the current one.
    ///
    /// # Examples
    ///
    /// ```
    /// use log::LevelFilter;
    ///
    /// let level_filter = LevelFilter::Info;
    ///
    /// assert_eq!(LevelFilter::Warn, level_filter.decrement_severity());
    /// assert_eq!(LevelFilter::Error, level_filter.decrement_severity().decrement_severity());
    /// assert_eq!(LevelFilter::Off, level_filter.decrement_severity().decrement_severity().decrement_severity());
    /// assert_eq!(LevelFilter::Off, level_filter.decrement_severity().decrement_severity().decrement_severity().decrement_severity()); // min level
    /// ```
    pub fn decrement_severity(&self) -> Self {
        let current = *self as usize;
        Self::from_usize(current.saturating_sub(1)).unwrap_or(*self)
    }
}

#[derive(Copy, Clone, Debug)]
enum MaybeStaticStr<'a> {
    Static(&'static str),
    Borrowed(&'a str),
}

impl<'a> MaybeStaticStr<'a> {
    #[inline]
    fn get(&self) -> &'a str {
        match *self {
            MaybeStaticStr::Static(s) => s,
            MaybeStaticStr::Borrowed(s) => s,
        }
    }
}

impl Eq for MaybeStaticStr<'_> {}

impl PartialEq for MaybeStaticStr<'_> {
    fn eq(&self, other: &Self) -> bool {
        self.get() == other.get()
    }
}

impl Ord for MaybeStaticStr<'_> {
    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
        self.get().cmp(other.get())
    }
}

impl PartialOrd for MaybeStaticStr<'_> {
    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl std::hash::Hash for MaybeStaticStr<'_> {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        self.get().hash(state);
    }
}

/// The "payload" of a log message.
///
/// # Use
///
/// `Record` structures are passed as parameters to the [`log`][method.log]
/// method of the [`Log`] trait. Logger implementors manipulate these
/// structures in order to display log messages. `Record`s are automatically
/// created by the [`log!`] macro and so are not seen by log users.
///
/// Note that the [`level()`] and [`target()`] accessors are equivalent to
/// `self.metadata().level()` and `self.metadata().target()` respectively.
/// These methods are provided as a convenience for users of this structure.
///
/// # Example
///
/// The following example shows a simple logger that displays the level,
/// module path, and message of any `Record` that is passed to it.
///
/// ```
/// struct SimpleLogger;
///
/// impl log::Log for SimpleLogger {
///    fn enabled(&self, _metadata: &log::Metadata) -> bool {
///        true
///    }
///
///    fn log(&self, record: &log::Record) {
///        if !self.enabled(record.metadata()) {
///            return;
///        }
///
///        println!("{}:{} -- {}",
///                 record.level(),
///                 record.target(),
///                 record.args());
///    }
///    fn flush(&self) {}
/// }
/// ```
///
/// [method.log]: trait.Log.html#tymethod.log
/// [`Log`]: trait.Log.html
/// [`log!`]: macro.log.html
/// [`level()`]: struct.Record.html#method.level
/// [`target()`]: struct.Record.html#method.target
#[derive(Clone, Debug)]
pub struct Record<'a> {
    metadata: Metadata<'a>,
    args: fmt::Arguments<'a>,
    module_path: Option<MaybeStaticStr<'a>>,
    file: Option<MaybeStaticStr<'a>>,
    line: Option<u32>,
    #[cfg(feature = "kv")]
    key_values: KeyValues<'a>,
}

// This wrapper type is only needed so we can
// `#[derive(Debug)]` on `Record`. It also
// provides a useful `Debug` implementation for
// the underlying `Source`.
#[cfg(feature = "kv")]
#[derive(Clone)]
struct KeyValues<'a>(&'a dyn kv::Source);

#[cfg(feature = "kv")]
impl<'a> fmt::Debug for KeyValues<'a> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        let mut visitor = f.debug_map();
        self.0.visit(&mut visitor).map_err(|_| fmt::Error)?;
        visitor.finish()
    }
}

impl<'a> Record<'a> {
    /// Returns a new builder.
    #[inline]
    pub fn builder() -> RecordBuilder<'a> {
        RecordBuilder::new()
    }

    /// The message body.
    #[inline]
    pub fn args(&self) -> &fmt::Arguments<'a> {
        &self.args
    }

    /// Metadata about the log directive.
    #[inline]
    pub fn metadata(&self) -> &Metadata<'a> {
        &self.metadata
    }

    /// The verbosity level of the message.
    #[inline]
    pub fn level(&self) -> Level {
        self.metadata.level()
    }

    /// The name of the target of the directive.
    #[inline]
    pub fn target(&self) -> &'a str {
        self.metadata.target()
    }

    /// The module path of the message.
    #[inline]
    pub fn module_path(&self) -> Option<&'a str> {
        self.module_path.map(|s| s.get())
    }

    /// The module path of the message, if it is a `'static` string.
    #[inline]
    pub fn module_path_static(&self) -> Option<&'static str> {
        match self.module_path {
            Some(MaybeStaticStr::Static(s)) => Some(s),
            _ => None,
        }
    }

    /// The source file containing the message.
    #[inline]
    pub fn file(&self) -> Option<&'a str> {
        self.file.map(|s| s.get())
    }

    /// The source file containing the message, if it is a `'static` string.
    #[inline]
    pub fn file_static(&self) -> Option<&'static str> {
        match self.file {
            Some(MaybeStaticStr::Static(s)) => Some(s),
            _ => None,
        }
    }

    /// The line containing the message.
    #[inline]
    pub fn line(&self) -> Option<u32> {
        self.line
    }

    /// The structured key-value pairs associated with the message.
    #[cfg(feature = "kv")]
    #[inline]
    pub fn key_values(&self) -> &dyn kv::Source {
        self.key_values.0
    }

    /// Create a new [`RecordBuilder`](struct.RecordBuilder.html) based on this record.
    #[cfg(feature = "kv")]
    #[inline]
    pub fn to_builder(&self) -> RecordBuilder<'_> {
        RecordBuilder {
            record: Record {
                metadata: Metadata {
                    level: self.metadata.level,
                    target: self.metadata.target,
                },
                args: self.args,
                module_path: self.module_path,
                file: self.file,
                line: self.line,
                key_values: self.key_values.clone(),
            },
        }
    }
}

/// Builder for [`Record`](struct.Record.html).
///
/// Typically should only be used by log library creators or for testing and "shim loggers".
/// The `RecordBuilder` can set the different parameters of `Record` object, and returns
/// the created object when `build` is called.
///
/// # Examples
///
/// ```
/// use log::{Level, Record};
///
/// let record = Record::builder()
///                 .args(format_args!("Error!"))
///                 .level(Level::Error)
///                 .target("myApp")
///                 .file(Some("server.rs"))
///                 .line(Some(144))
///                 .module_path(Some("server"))
///                 .build();
/// ```
///
/// Alternatively, use [`MetadataBuilder`](struct.MetadataBuilder.html):
///
/// ```
/// use log::{Record, Level, MetadataBuilder};
///
/// let error_metadata = MetadataBuilder::new()
///                         .target("myApp")
///                         .level(Level::Error)
///                         .build();
///
/// let record = Record::builder()
///                 .metadata(error_metadata)
///                 .args(format_args!("Error!"))
///                 .line(Some(433))
///                 .file(Some("app.rs"))
///                 .module_path(Some("server"))
///                 .build();
/// ```
#[derive(Debug)]
pub struct RecordBuilder<'a> {
    record: Record<'a>,
}

impl<'a> RecordBuilder<'a> {
    /// Construct new `RecordBuilder`.
    ///
    /// The default options are:
    ///
    /// - `args`: [`format_args!("")`]
    /// - `metadata`: [`Metadata::builder().build()`]
    /// - `module_path`: `None`
    /// - `file`: `None`
    /// - `line`: `None`
    ///
    /// [`format_args!("")`]: https://doc.rust-lang.org/std/macro.format_args.html
    /// [`Metadata::builder().build()`]: struct.MetadataBuilder.html#method.build
    #[inline]
    pub fn new() -> RecordBuilder<'a> {
        RecordBuilder {
            record: Record {
                args: format_args!(""),
                metadata: Metadata::builder().build(),
                module_path: None,
                file: None,
                line: None,
                #[cfg(feature = "kv")]
                key_values: KeyValues(&None::<(kv::Key, kv::Value)>),
            },
        }
    }

    /// Set [`args`](struct.Record.html#method.args).
    #[inline]
    pub fn args(&mut self, args: fmt::Arguments<'a>) -> &mut RecordBuilder<'a> {
        self.record.args = args;
        self
    }

    /// Set [`metadata`](struct.Record.html#method.metadata). Construct a `Metadata` object with [`MetadataBuilder`](struct.MetadataBuilder.html).
    #[inline]
    pub fn metadata(&mut self, metadata: Metadata<'a>) -> &mut RecordBuilder<'a> {
        self.record.metadata = metadata;
        self
    }

    /// Set [`Metadata::level`](struct.Metadata.html#method.level).
    #[inline]
    pub fn level(&mut self, level: Level) -> &mut RecordBuilder<'a> {
        self.record.metadata.level = level;
        self
    }

    /// Set [`Metadata::target`](struct.Metadata.html#method.target)
    #[inline]
    pub fn target(&mut self, target: &'a str) -> &mut RecordBuilder<'a> {
        self.record.metadata.target = target;
        self
    }

    /// Set [`module_path`](struct.Record.html#method.module_path)
    #[inline]
    pub fn module_path(&mut self, path: Option<&'a str>) -> &mut RecordBuilder<'a> {
        self.record.module_path = path.map(MaybeStaticStr::Borrowed);
        self
    }

    /// Set [`module_path`](struct.Record.html#method.module_path) to a `'static` string
    #[inline]
    pub fn module_path_static(&mut self, path: Option<&'static str>) -> &mut RecordBuilder<'a> {
        self.record.module_path = path.map(MaybeStaticStr::Static);
        self
    }

    /// Set [`file`](struct.Record.html#method.file)
    #[inline]
    pub fn file(&mut self, file: Option<&'a str>) -> &mut RecordBuilder<'a> {
        self.record.file = file.map(MaybeStaticStr::Borrowed);
        self
    }

    /// Set [`file`](struct.Record.html#method.file) to a `'static` string.
    #[inline]
    pub fn file_static(&mut self, file: Option<&'static str>) -> &mut RecordBuilder<'a> {
        self.record.file = file.map(MaybeStaticStr::Static);
        self
    }

    /// Set [`line`](struct.Record.html#method.line)
    #[inline]
    pub fn line(&mut self, line: Option<u32>) -> &mut RecordBuilder<'a> {
        self.record.line = line;
        self
    }

    /// Set [`key_values`](struct.Record.html#method.key_values)
    #[cfg(feature = "kv")]
    #[inline]
    pub fn key_values(&mut self, kvs: &'a dyn kv::Source) -> &mut RecordBuilder<'a> {
        self.record.key_values = KeyValues(kvs);
        self
    }

    /// Invoke the builder and return a `Record`
    #[inline]
    pub fn build(&self) -> Record<'a> {
        self.record.clone()
    }
}

impl Default for RecordBuilder<'_> {
    fn default() -> Self {
        Self::new()
    }
}

/// Metadata about a log message.
///
/// # Use
///
/// `Metadata` structs are created when users of the library use
/// logging macros.
///
/// They are consumed by implementations of the `Log` trait in the
/// `enabled` method.
///
/// `Record`s use `Metadata` to determine the log message's severity
/// and target.
///
/// Users should use the `log_enabled!` macro in their code to avoid
/// constructing expensive log messages.
///
/// # Examples
///
/// ```
/// use log::{Record, Level, Metadata};
///
/// struct MyLogger;
///
/// impl log::Log for MyLogger {
///     fn enabled(&self, metadata: &Metadata) -> bool {
///         metadata.level() <= Level::Info
///     }
///
///     fn log(&self, record: &Record) {
///         if self.enabled(record.metadata()) {
///             println!("{} - {}", record.level(), record.args());
///         }
///     }
///     fn flush(&self) {}
/// }
///
/// # fn main(){}
/// ```
#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
pub struct Metadata<'a> {
    level: Level,
    target: &'a str,
}

impl<'a> Metadata<'a> {
    /// Returns a new builder.
    #[inline]
    pub fn builder() -> MetadataBuilder<'a> {
        MetadataBuilder::new()
    }

    /// The verbosity level of the message.
    #[inline]
    pub fn level(&self) -> Level {
        self.level
    }

    /// The name of the target of the directive.
    #[inline]
    pub fn target(&self) -> &'a str {
        self.target
    }
}

/// Builder for [`Metadata`](struct.Metadata.html).
///
/// Typically should only be used by log library creators or for testing and "shim loggers".
/// The `MetadataBuilder` can set the different parameters of a `Metadata` object, and returns
/// the created object when `build` is called.
///
/// # Example
///
/// ```
/// let target = "myApp";
/// use log::{Level, MetadataBuilder};
/// let metadata = MetadataBuilder::new()
///                     .level(Level::Debug)
///                     .target(target)
///                     .build();
/// ```
#[derive(Eq, PartialEq, Ord, PartialOrd, Hash, Debug)]
pub struct MetadataBuilder<'a> {
    metadata: Metadata<'a>,
}

impl<'a> MetadataBuilder<'a> {
    /// Construct a new `MetadataBuilder`.
    ///
    /// The default options are:
    ///
    /// - `level`: `Level::Info`
    /// - `target`: `""`
    #[inline]
    pub fn new() -> MetadataBuilder<'a> {
        MetadataBuilder {
            metadata: Metadata {
                level: Level::Info,
                target: "",
            },
        }
    }

    /// Setter for [`level`](struct.Metadata.html#method.level).
    #[inline]
    pub fn level(&mut self, arg: Level) -> &mut MetadataBuilder<'a> {
        self.metadata.level = arg;
        self
    }

    /// Setter for [`target`](struct.Metadata.html#method.target).
    #[inline]
    pub fn target(&mut self, target: &'a str) -> &mut MetadataBuilder<'a> {
        self.metadata.target = target;
        self
    }

    /// Returns a `Metadata` object.
    #[inline]
    pub fn build(&self) -> Metadata<'a> {
        self.metadata.clone()
    }
}

impl Default for MetadataBuilder<'_> {
    fn default() -> Self {
        Self::new()
    }
}

/// A trait encapsulating the operations required of a logger.
pub trait Log: Sync + Send {
    /// Determines if a log message with the specified metadata would be
    /// logged.
    ///
    /// This is used by the `log_enabled!` macro to allow callers to avoid
    /// expensive computation of log message arguments if the message would be
    /// discarded anyway.
    ///
    /// # For implementors
    ///
    /// This method isn't called automatically by the `log!` macros.
    /// It's up to an implementation of the `Log` trait to call `enabled` in its own
    /// `log` method implementation to guarantee that filtering is applied.
    fn enabled(&self, metadata: &Metadata) -> bool;

    /// Logs the `Record`.
    ///
    /// # For implementors
    ///
    /// Note that `enabled` is *not* necessarily called before this method.
    /// Implementations of `log` should perform all necessary filtering
    /// internally.
    fn log(&self, record: &Record);

    /// Flushes any buffered records.
    ///
    /// # For implementors
    ///
    /// This method isn't called automatically by the `log!` macros.
    /// It can be called manually on shut-down to ensure any in-flight records are flushed.
    fn flush(&self);
}

/// A dummy initial value for LOGGER.
struct NopLogger;

impl Log for NopLogger {
    fn enabled(&self, _: &Metadata) -> bool {
        false
    }

    fn log(&self, _: &Record) {}
    fn flush(&self) {}
}

impl<T> Log for &'_ T
where
    T: ?Sized + Log,
{
    fn enabled(&self, metadata: &Metadata) -> bool {
        (**self).enabled(metadata)
    }

    fn log(&self, record: &Record) {
        (**self).log(record);
    }
    fn flush(&self) {
        (**self).flush();
    }
}

#[cfg(feature = "std")]
impl<T> Log for std::boxed::Box<T>
where
    T: ?Sized + Log,
{
    fn enabled(&self, metadata: &Metadata) -> bool {
        self.as_ref().enabled(metadata)
    }

    fn log(&self, record: &Record) {
        self.as_ref().log(record);
    }
    fn flush(&self) {
        self.as_ref().flush();
    }
}

#[cfg(feature = "std")]
impl<T> Log for std::sync::Arc<T>
where
    T: ?Sized + Log,
{
    fn enabled(&self, metadata: &Metadata) -> bool {
        self.as_ref().enabled(metadata)
    }

    fn log(&self, record: &Record) {
        self.as_ref().log(record);
    }
    fn flush(&self) {
        self.as_ref().flush();
    }
}

/// Sets the global maximum log level.
///
/// Generally, this should only be called by the active logging implementation.
///
/// Note that `Trace` is the maximum level, because it provides the maximum amount of detail in the emitted logs.
#[inline]
#[cfg(target_has_atomic = "ptr")]
pub fn set_max_level(level: LevelFilter) {
    MAX_LOG_LEVEL_FILTER.store(level as usize, Ordering::Relaxed);
}

/// A thread-unsafe version of [`set_max_level`].
///
/// This function is available on all platforms, even those that do not have
/// support for atomics that is needed by [`set_max_level`].
///
/// In almost all cases, [`set_max_level`] should be preferred.
///
/// # Safety
///
/// This function is only safe to call when it cannot race with any other
/// calls to `set_max_level` or `set_max_level_racy`.
///
/// This can be upheld by (for example) making sure that **there are no other
/// threads**, and (on embedded) that **interrupts are disabled**.
///
/// It is safe to use all other logging functions while this function runs
/// (including all logging macros).
///
/// [`set_max_level`]: fn.set_max_level.html
#[inline]
pub unsafe fn set_max_level_racy(level: LevelFilter) {
    // `MAX_LOG_LEVEL_FILTER` uses a `Cell` as the underlying primitive when a
    // platform doesn't support `target_has_atomic = "ptr"`, so even though this looks the same
    // as `set_max_level` it may have different safety properties.
    MAX_LOG_LEVEL_FILTER.store(level as usize, Ordering::Relaxed);
}

/// Returns the current maximum log level.
///
/// The [`log!`], [`error!`], [`warn!`], [`info!`], [`debug!`], and [`trace!`] macros check
/// this value and discard any message logged at a higher level. The maximum
/// log level is set by the [`set_max_level`] function.
///
/// [`log!`]: macro.log.html
/// [`error!`]: macro.error.html
/// [`warn!`]: macro.warn.html
/// [`info!`]: macro.info.html
/// [`debug!`]: macro.debug.html
/// [`trace!`]: macro.trace.html
/// [`set_max_level`]: fn.set_max_level.html
#[inline(always)]
pub fn max_level() -> LevelFilter {
    // Since `LevelFilter` is `repr(usize)`,
    // this transmute is sound if and only if `MAX_LOG_LEVEL_FILTER`
    // is set to a usize that is a valid discriminant for `LevelFilter`.
    // Since `MAX_LOG_LEVEL_FILTER` is private, the only time it's set
    // is by `set_max_level` above, i.e. by casting a `LevelFilter` to `usize`.
    // So any usize stored in `MAX_LOG_LEVEL_FILTER` is a valid discriminant.
    unsafe { mem::transmute(MAX_LOG_LEVEL_FILTER.load(Ordering::Relaxed)) }
}

/// Sets the global logger to a `Box<Log>`.
///
/// This is a simple convenience wrapper over `set_logger`, which takes a
/// `Box<Log>` rather than a `&'static Log`. See the documentation for
/// [`set_logger`] for more details.
///
/// Requires the `std` feature.
///
/// # Errors
///
/// An error is returned if a logger has already been set.
///
/// [`set_logger`]: fn.set_logger.html
#[cfg(all(feature = "std", target_has_atomic = "ptr"))]
pub fn set_boxed_logger(logger: Box<dyn Log>) -> Result<(), SetLoggerError> {
    set_logger_inner(|| Box::leak(logger))
}

/// Sets the global logger to a `&'static Log`.
///
/// This function may only be called once in the lifetime of a program. Any log
/// events that occur before the call to `set_logger` completes will be ignored.
///
/// This function does not typically need to be called manually. Logger
/// implementations should provide an initialization method that installs the
/// logger internally.
///
/// # Availability
///
/// This method is available even when the `std` feature is disabled. However,
/// it is currently unavailable on `thumbv6` targets, which lack support for
/// some atomic operations which are used by this function. Even on those
/// targets, [`set_logger_racy`] will be available.
///
/// # Errors
///
/// An error is returned if a logger has already been set.
///
/// # Examples
///
/// ```
/// use log::{error, info, warn, Record, Level, Metadata, LevelFilter};
///
/// static MY_LOGGER: MyLogger = MyLogger;
///
/// struct MyLogger;
///
/// impl log::Log for MyLogger {
///     fn enabled(&self, metadata: &Metadata) -> bool {
///         metadata.level() <= Level::Info
///     }
///
///     fn log(&self, record: &Record) {
///         if self.enabled(record.metadata()) {
///             println!("{} - {}", record.level(), record.args());
///         }
///     }
///     fn flush(&self) {}
/// }
///
/// # fn main(){
/// log::set_logger(&MY_LOGGER).unwrap();
/// log::set_max_level(LevelFilter::Info);
///
/// info!("hello log");
/// warn!("warning");
/// error!("oops");
/// # }
/// ```
///
/// [`set_logger_racy`]: fn.set_logger_racy.html
#[cfg(target_has_atomic = "ptr")]
pub fn set_logger(logger: &'static dyn Log) -> Result<(), SetLoggerError> {
    set_logger_inner(|| logger)
}

#[cfg(target_has_atomic = "ptr")]
fn set_logger_inner<F>(make_logger: F) -> Result<(), SetLoggerError>
where
    F: FnOnce() -> &'static dyn Log,
{
    match STATE.compare_exchange(
        UNINITIALIZED,
        INITIALIZING,
        Ordering::Acquire,
        Ordering::Relaxed,
    ) {
        Ok(UNINITIALIZED) => {
            unsafe {
                LOGGER = make_logger();
            }
            STATE.store(INITIALIZED, Ordering::Release);
            Ok(())
        }
        Err(INITIALIZING) => {
            while STATE.load(Ordering::Relaxed) == INITIALIZING {
                std::hint::spin_loop();
            }
            Err(SetLoggerError(()))
        }
        _ => Err(SetLoggerError(())),
    }
}

/// A thread-unsafe version of [`set_logger`].
///
/// This function is available on all platforms, even those that do not have
/// support for atomics that is needed by [`set_logger`].
///
/// In almost all cases, [`set_logger`] should be preferred.
///
/// # Safety
///
/// This function is only safe to call when it cannot race with any other
/// calls to `set_logger` or `set_logger_racy`.
///
/// This can be upheld by (for example) making sure that **there are no other
/// threads**, and (on embedded) that **interrupts are disabled**.
///
/// It is safe to use other logging functions while this function runs
/// (including all logging macros).
///
/// [`set_logger`]: fn.set_logger.html
pub unsafe fn set_logger_racy(logger: &'static dyn Log) -> Result<(), SetLoggerError> {
    match STATE.load(Ordering::Acquire) {
        UNINITIALIZED => {
            LOGGER = logger;
            STATE.store(INITIALIZED, Ordering::Release);
            Ok(())
        }
        INITIALIZING => {
            // This is just plain UB, since we were racing another initialization function
            unreachable!("set_logger_racy must not be used with other initialization functions")
        }
        _ => Err(SetLoggerError(())),
    }
}

/// The type returned by [`set_logger`] if [`set_logger`] has already been called.
///
/// [`set_logger`]: fn.set_logger.html
#[allow(missing_copy_implementations)]
#[derive(Debug)]
pub struct SetLoggerError(());

impl fmt::Display for SetLoggerError {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.write_str(SET_LOGGER_ERROR)
    }
}

// The Error trait is not available in libcore
#[cfg(feature = "std")]
impl error::Error for SetLoggerError {}

/// The type returned by [`from_str`] when the string doesn't match any of the log levels.
///
/// [`from_str`]: https://doc.rust-lang.org/std/str/trait.FromStr.html#tymethod.from_str
#[allow(missing_copy_implementations)]
#[derive(Debug, PartialEq, Eq)]
pub struct ParseLevelError(());

impl fmt::Display for ParseLevelError {
    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
        fmt.write_str(LEVEL_PARSE_ERROR)
    }
}

// The Error trait is not available in libcore
#[cfg(feature = "std")]
impl error::Error for ParseLevelError {}

/// Returns a reference to the logger.
///
/// If a logger has not been set, a no-op implementation is returned.
pub fn logger() -> &'static dyn Log {
    // Acquire memory ordering guarantees that current thread would see any
    // memory writes that happened before store of the value
    // into `STATE` with memory ordering `Release` or stronger.
    //
    // Since the value `INITIALIZED` is written only after `LOGGER` was
    // initialized, observing it after `Acquire` load here makes both
    // write to the `LOGGER` static and initialization of the logger
    // internal state synchronized with current thread.
    if STATE.load(Ordering::Acquire) != INITIALIZED {
        static NOP: NopLogger = NopLogger;
        &NOP
    } else {
        unsafe { LOGGER }
    }
}

// WARNING: this is not part of the crate's public API and is subject to change at any time
#[doc(hidden)]
pub mod __private_api;

/// The statically resolved maximum log level.
///
/// See the crate level documentation for information on how to configure this.
///
/// This value is checked by the log macros, but not by the `Log`ger returned by
/// the [`logger`] function. Code that manually calls functions on that value
/// should compare the level against this value.
///
/// [`logger`]: fn.logger.html
pub const STATIC_MAX_LEVEL: LevelFilter = match cfg!(debug_assertions) {
    false if cfg!(feature = "release_max_level_off") => LevelFilter::Off,
    false if cfg!(feature = "release_max_level_error") => LevelFilter::Error,
    false if cfg!(feature = "release_max_level_warn") => LevelFilter::Warn,
    false if cfg!(feature = "release_max_level_info") => LevelFilter::Info,
    false if cfg!(feature = "release_max_level_debug") => LevelFilter::Debug,
    false if cfg!(feature = "release_max_level_trace") => LevelFilter::Trace,
    _ if cfg!(feature = "max_level_off") => LevelFilter::Off,
    _ if cfg!(feature = "max_level_error") => LevelFilter::Error,
    _ if cfg!(feature = "max_level_warn") => LevelFilter::Warn,
    _ if cfg!(feature = "max_level_info") => LevelFilter::Info,
    _ if cfg!(feature = "max_level_debug") => LevelFilter::Debug,
    _ => LevelFilter::Trace,
};

#[cfg(test)]
mod tests {
    use super::{Level, LevelFilter, ParseLevelError, STATIC_MAX_LEVEL};

    #[test]
    fn test_levelfilter_from_str() {
        let tests = [
            ("off", Ok(LevelFilter::Off)),
            ("error", Ok(LevelFilter::Error)),
            ("warn", Ok(LevelFilter::Warn)),
            ("info", Ok(LevelFilter::Info)),
            ("debug", Ok(LevelFilter::Debug)),
            ("trace", Ok(LevelFilter::Trace)),
            ("OFF", Ok(LevelFilter::Off)),
            ("ERROR", Ok(LevelFilter::Error)),
            ("WARN", Ok(LevelFilter::Warn)),
            ("INFO", Ok(LevelFilter::Info)),
            ("DEBUG", Ok(LevelFilter::Debug)),
            ("TRACE", Ok(LevelFilter::Trace)),
            ("asdf", Err(ParseLevelError(()))),
        ];
        for &(s, ref expected) in &tests {
            assert_eq!(expected, &s.parse());
        }
    }

    #[test]
    fn test_level_from_str() {
        let tests = [
            ("OFF", Err(ParseLevelError(()))),
            ("error", Ok(Level::Error)),
            ("warn", Ok(Level::Warn)),
            ("info", Ok(Level::Info)),
            ("debug", Ok(Level::Debug)),
            ("trace", Ok(Level::Trace)),
            ("ERROR", Ok(Level::Error)),
            ("WARN", Ok(Level::Warn)),
            ("INFO", Ok(Level::Info)),
            ("DEBUG", Ok(Level::Debug)),
            ("TRACE", Ok(Level::Trace)),
            ("asdf", Err(ParseLevelError(()))),
        ];
        for &(s, ref expected) in &tests {
            assert_eq!(expected, &s.parse());
        }
    }

    #[test]
    fn test_level_as_str() {
        let tests = &[
            (Level::Error, "ERROR"),
            (Level::Warn, "WARN"),
            (Level::Info, "INFO"),
            (Level::Debug, "DEBUG"),
            (Level::Trace, "TRACE"),
        ];
        for (input, expected) in tests {
            assert_eq!(*expected, input.as_str());
        }
    }

    #[test]
    fn test_level_show() {
        assert_eq!("INFO", Level::Info.to_string());
        assert_eq!("ERROR", Level::Error.to_string());
    }

    #[test]
    fn test_levelfilter_show() {
        assert_eq!("OFF", LevelFilter::Off.to_string());
        assert_eq!("ERROR", LevelFilter::Error.to_string());
    }

    #[test]
    fn test_cross_cmp() {
        assert!(Level::Debug > LevelFilter::Error);
        assert!(LevelFilter::Warn < Level::Trace);
        assert!(LevelFilter::Off < Level::Error);
    }

    #[test]
    fn test_cross_eq() {
        assert!(Level::Error == LevelFilter::Error);
        assert!(LevelFilter::Off != Level::Error);
        assert!(Level::Trace == LevelFilter::Trace);
    }

    #[test]
    fn test_to_level() {
        assert_eq!(Some(Level::Error), LevelFilter::Error.to_level());
        assert_eq!(None, LevelFilter::Off.to_level());
        assert_eq!(Some(Level::Debug), LevelFilter::Debug.to_level());
    }

    #[test]
    fn test_to_level_filter() {
        assert_eq!(LevelFilter::Error, Level::Error.to_level_filter());
        assert_eq!(LevelFilter::Trace, Level::Trace.to_level_filter());
    }

    #[test]
    fn test_level_filter_as_str() {
        let tests = &[
            (LevelFilter::Off, "OFF"),
            (LevelFilter::Error, "ERROR"),
            (LevelFilter::Warn, "WARN"),
            (LevelFilter::Info, "INFO"),
            (LevelFilter::Debug, "DEBUG"),
            (LevelFilter::Trace, "TRACE"),
        ];
        for (input, expected) in tests {
            assert_eq!(*expected, input.as_str());
        }
    }

    #[test]
    fn test_level_up() {
        let info = Level::Info;
        let up = info.increment_severity();
        assert_eq!(up, Level::Debug);

        let trace = Level::Trace;
        let up = trace.increment_severity();
        // trace is already highest level
        assert_eq!(up, trace);
    }

    #[test]
    fn test_level_filter_up() {
        let info = LevelFilter::Info;
        let up = info.increment_severity();
        assert_eq!(up, LevelFilter::Debug);

        let trace = LevelFilter::Trace;
        let up = trace.increment_severity();
        // trace is already highest level
        assert_eq!(up, trace);
    }

    #[test]
    fn test_level_down() {
        let info = Level::Info;
        let down = info.decrement_severity();
        assert_eq!(down, Level::Warn);

        let error = Level::Error;
        let down = error.decrement_severity();
        // error is already lowest level
        assert_eq!(down, error);
    }

    #[test]
    fn test_level_filter_down() {
        let info = LevelFilter::Info;
        let down = info.decrement_severity();
        assert_eq!(down, LevelFilter::Warn);

        let error = LevelFilter::Error;
        let down = error.decrement_severity();
        assert_eq!(down, LevelFilter::Off);
        // Off is already the lowest
        assert_eq!(down.decrement_severity(), down);
    }

    #[test]
    #[cfg_attr(not(debug_assertions), ignore)]
    fn test_static_max_level_debug() {
        if cfg!(feature = "max_level_off") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Off);
        } else if cfg!(feature = "max_level_error") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Error);
        } else if cfg!(feature = "max_level_warn") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Warn);
        } else if cfg!(feature = "max_level_info") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Info);
        } else if cfg!(feature = "max_level_debug") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Debug);
        } else {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Trace);
        }
    }

    #[test]
    #[cfg_attr(debug_assertions, ignore)]
    fn test_static_max_level_release() {
        if cfg!(feature = "release_max_level_off") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Off);
        } else if cfg!(feature = "release_max_level_error") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Error);
        } else if cfg!(feature = "release_max_level_warn") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Warn);
        } else if cfg!(feature = "release_max_level_info") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Info);
        } else if cfg!(feature = "release_max_level_debug") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Debug);
        } else if cfg!(feature = "release_max_level_trace") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Trace);
        } else if cfg!(feature = "max_level_off") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Off);
        } else if cfg!(feature = "max_level_error") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Error);
        } else if cfg!(feature = "max_level_warn") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Warn);
        } else if cfg!(feature = "max_level_info") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Info);
        } else if cfg!(feature = "max_level_debug") {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Debug);
        } else {
            assert_eq!(STATIC_MAX_LEVEL, LevelFilter::Trace);
        }
    }

    #[test]
    #[cfg(feature = "std")]
    fn test_error_trait() {
        use super::SetLoggerError;
        let e = SetLoggerError(());
        assert_eq!(
            &e.to_string(),
            "attempted to set a logger after the logging system \
             was already initialized"
        );
    }

    #[test]
    fn test_metadata_builder() {
        use super::MetadataBuilder;
        let target = "myApp";
        let metadata_test = MetadataBuilder::new()
            .level(Level::Debug)
            .target(target)
            .build();
        assert_eq!(metadata_test.level(), Level::Debug);
        assert_eq!(metadata_test.target(), "myApp");
    }

    #[test]
    fn test_metadata_convenience_builder() {
        use super::Metadata;
        let target = "myApp";
        let metadata_test = Metadata::builder()
            .level(Level::Debug)
            .target(target)
            .build();
        assert_eq!(metadata_test.level(), Level::Debug);
        assert_eq!(metadata_test.target(), "myApp");
    }

    #[test]
    fn test_record_builder() {
        use super::{MetadataBuilder, RecordBuilder};
        let target = "myApp";
        let metadata = MetadataBuilder::new().target(target).build();
        let fmt_args = format_args!("hello");
        let record_test = RecordBuilder::new()
            .args(fmt_args)
            .metadata(metadata)
            .module_path(Some("foo"))
            .file(Some("bar"))
            .line(Some(30))
            .build();
        assert_eq!(record_test.metadata().target(), "myApp");
        assert_eq!(record_test.module_path(), Some("foo"));
        assert_eq!(record_test.file(), Some("bar"));
        assert_eq!(record_test.line(), Some(30));
    }

    #[test]
    fn test_record_convenience_builder() {
        use super::{Metadata, Record};
        let target = "myApp";
        let metadata = Metadata::builder().target(target).build();
        let fmt_args = format_args!("hello");
        let record_test = Record::builder()
            .args(fmt_args)
            .metadata(metadata)
            .module_path(Some("foo"))
            .file(Some("bar"))
            .line(Some(30))
            .build();
        assert_eq!(record_test.target(), "myApp");
        assert_eq!(record_test.module_path(), Some("foo"));
        assert_eq!(record_test.file(), Some("bar"));
        assert_eq!(record_test.line(), Some(30));
    }

    #[test]
    fn test_record_complete_builder() {
        use super::{Level, Record};
        let target = "myApp";
        let record_test = Record::builder()
            .module_path(Some("foo"))
            .file(Some("bar"))
            .line(Some(30))
            .target(target)
            .level(Level::Error)
            .build();
        assert_eq!(record_test.target(), "myApp");
        assert_eq!(record_test.level(), Level::Error);
        assert_eq!(record_test.module_path(), Some("foo"));
        assert_eq!(record_test.file(), Some("bar"));
        assert_eq!(record_test.line(), Some(30));
    }

    #[test]
    #[cfg(feature = "kv")]
    fn test_record_key_values_builder() {
        use super::Record;
        use crate::kv::{self, VisitSource};

        struct TestVisitSource {
            seen_pairs: usize,
        }

        impl<'kvs> VisitSource<'kvs> for TestVisitSource {
            fn visit_pair(
                &mut self,
                _: kv::Key<'kvs>,
                _: kv::Value<'kvs>,
            ) -> Result<(), kv::Error> {
                self.seen_pairs += 1;
                Ok(())
            }
        }

        let kvs: &[(&str, i32)] = &[("a", 1), ("b", 2)];
        let record_test = Record::builder().key_values(&kvs).build();

        let mut visitor = TestVisitSource { seen_pairs: 0 };

        record_test.key_values().visit(&mut visitor).unwrap();

        assert_eq!(2, visitor.seen_pairs);
    }

    #[test]
    #[cfg(feature = "kv")]
    fn test_record_key_values_get_coerce() {
        use super::Record;

        let kvs: &[(&str, &str)] = &[("a", "1"), ("b", "2")];
        let record = Record::builder().key_values(&kvs).build();

        assert_eq!(
            "2",
            record
                .key_values()
                .get("b".into())
                .expect("missing key")
                .to_borrowed_str()
                .expect("invalid value")
        );
    }

    // Test that the `impl Log for Foo` blocks work
    // This test mostly operates on a type level, so failures will be compile errors
    #[test]
    fn test_foreign_impl() {
        use super::Log;
        #[cfg(feature = "std")]
        use std::sync::Arc;

        fn assert_is_log<T: Log + ?Sized>() {}

        assert_is_log::<&dyn Log>();

        #[cfg(feature = "std")]
        assert_is_log::<Box<dyn Log>>();

        #[cfg(feature = "std")]
        assert_is_log::<Arc<dyn Log>>();

        // Assert these statements for all T: Log + ?Sized
        #[allow(unused)]
        fn forall<T: Log + ?Sized>() {
            #[cfg(feature = "std")]
            assert_is_log::<Box<T>>();

            assert_is_log::<&T>();

            #[cfg(feature = "std")]
            assert_is_log::<Arc<T>>();
        }
    }
}

מדפסת הזרקת דיו (באנגלית: Inkjet) היא מדפסת הפועלת בטכנולוגיית הדפסה המבוססת על סדרת מזרקים זעירים המתיזים טיפות דיו קטנות אל הנייר העובר מתחת לרצועה שבה הם נמצאים. ראש ה"מזריק דיו" כמעט צמוד לנייר בעת ההדפסה, כשראש הדיו נמצא במקום הנקבע על ידי המערכת הוא מתיז כמות מזערית של הדיו על הנייר ושואב את הדיו המיותר על מנת למנוע היווצרות כתמים. פעולה זו מתבצעת על ידי צינור מזערי שעוביו קטן יותר מעוביה של השערה האנושית.

השיטות העיקריות להזרקת הדיו
 החברות אפסון וברדר משתמשות בגביש פיזואלקטרי אשר משנה את צורתו בעת הזרמת זרם חשמלי ודוחף את טיפת הדיו לנייר. 
 שיטת הבועות: בתוך הצינור ישנו נגד קטן שפועל כגוף חימום, בעת הזרמת זרם חשמלי הוא מחמם את הדיו עד שטיפה מהדיו מתאדה. נפח אדי הדיו גדול מדיו נוזלי, וכך מאדי דיו מתנפחת בועה בתוך הצינור, הבועה דוחפת טיפה של דיו מחוץ לצינור, באמצעות אלפי פיפטות מזעריות האדים חוזרים למצב צבירה נוזלי וכתוצאה מהתכווצות הבועה טיפה מהדיו שנשפך חוזר פנימה ומונעת טפטוף.

מחיר מדפסת הזרקת דיו נמוך יחסית למדפסת לייזר.

קישורים חיצוניים

 מישל רוזנברג, על הזרקת דיו, באתר אימגו, 31 דצמבר 2012
 

ערכים שבהם תבנית בריטניקה אינה מתאימה
דיו

Το γράμμα ήτα (κεφαλαίο Η, πεζό η) είναι το έβδομο γράμμα του ελληνικού αλφαβήτου. Στο ευκλείδειο αλφάβητο κατείχε την όγδοη θέση.

Στο ελληνικό σύστημα αρίθμησης έχει αριθμητική αξία η´=8.

Προέλευση
Προέρχεται από το φοινικικό γράμμα χεθ  και σε ορισμένα τοπικά αλφάβητα της αρχαίας Ελλάδας διατήρησε και την μορφή αυτήν. Στα περισσότερα αλφάβητα συμβόλιζε τον δασύ ήχο του πνεύματος της δασείας και προφερόταν ως  (ēta). Στο ιωνικό αλφάβητο όμως, επειδή η ιωνική διάλεκτος απώλεσε τον αρχικό δασύ φθόγγο στις λέξεις («ψίλωση»), κατέληξε να προφέρεται ως  (ēta) και να συμβολίζει το μακρόχρονο φωνήεν [ē]. Όταν όμως καθιερώθηκε το ιωνικό αλφάβητο σε πολλές περιοχές της αρχαίας Ελλάδας, προέκυψε η ανάγκη να αποδίδεται με κάποιον τρόπο ο δασύς φθόγγος, μια και το ήτα ήταν πλέον [ē]. Έτσι κατέληξαν να χρησιμοποιούνται τα δύο μισά του Η, το μεν αριστερό ἧτα (├) ως δασύς φθόγγος, το δε δεξιό για να αποδώσει την έλλειψη δασύτητας ἦτα (┤). Τα πνεύματα δασεία ( ) και ψιλή () όπως τα ξέρουμε σήμερα προέκυψαν από το αριστερό και το δεξί μισό του Η αντίστοιχα.

Προφορά
Στη σύγχρονη προφορά ταυτίζεται με το ι. Η εξέλιξη αυτή στην προφορά πραγματοποιήθηκε κατά την περίοδο της κοινής ελληνικής και ονομάστηκε ιωτακισμός).

Το Η αντιστοιχεί στο λατινικό H h, όταν συμβολίζει τον ήχο της δασείας (π.χ. Ελλάς → Hellas), αλλά στο E e (π.χ. Άρης → Ares) ή στο I i, όταν συμβολίζει φωνήεν (π.χ. Αθήνα → Athina).

Το Η συμβόλιζε σε ένα αρχαιότερο ελληνικό σύστημα αρίθμησης, το ακροφωνικό σύστημα αρίθμησης, τον αριθμό 100, από το πρώτο γράμμα της λέξης  που γράφονταν ΗΕΚΑΤΟΝ → ἑκατόν (όπου το αρχικό Η αντικαταστάθηκε τελικά από το πνεύμα της δασείας).

Πηγές

Εξωτερικοί σύνδεσμοι 

η

गोवा या गोआ (कोंकणी: गोंय), क्षेत्रफल के अनुसार से भारत का सबसे छोटा और जनसंख्या के अनुसार चौथा सबसे छोटा राज्य है। पूरी दुनिया में गोवा अपने सुन्दर समुद्र के किनारों और प्रसिद्ध स्थापत्य के लिये जाना जाता है। गोवा पहले पुर्तगाल का एक उपनिवेश था। पुर्तगालियों ने गोवा पर लगभग 450 सालों तक शासन किया और 19 दिसंबर 1961 में यह भारतीय प्रशासन को सौंपा गया।

गोवा

नाम का उद्भव 
महाभारत में गोवा का उल्लेख गोपराष्ट्र यानि गोपालकों के देश के रूप में मिलता है। दक्षिण कोंकण क्षेत्र का उल्लेख गोवाराष्ट्र के रूप में पाया जाता है। संस्कृत के कुछ अन्य पुराने स्त्रोतों में गोवा को गोपकपुरी और गोपकपट्टन कहा गया है जिनका उल्लेख अन्य ग्रंथों के अलावा हरिवंशम और स्कंद पुराण में मिलता है। गोवा को बाद में कहीं कहीं गोअंचल भी कहा गया है। अन्य नामों में गोवे, गोवापुरी, गोपकापाटन औरगोमंत प्रमुख हैं। टोलेमी ने गोवा का उल्लेख वर्ष 200 के आस-पास गोउबा के रूप में किया है। अरब के मध्युगीन यात्रियों ने इस क्षेत्र को चंद्रपुर और चंदौर के नाम से इंगित किया है जो मुख्य रूप से एक तटीय शहर था। जिस स्थान का नाम पुर्तगाल के यात्रियों ने गोवा रखा वह आज का छोटा सा समुद्र तटीय शहर गोअ-वेल्हा है। बाद में उस पूरे क्षेत्र को गोवा कहा जाने लगा जिस पर पुर्तगालियों ने कब्जा किया।

जनश्रुति के अनुसार गोवा जिसमें कोंकण क्षेत्र भी शामिल है (और जिसका विस्तार गुजरात से केरल तक बताया जाता है) की रचना भगवान परशुराम ने की थी। कहा जाता है कि परशुराम ने एक यज्ञ के दौरान अपने बाणो की वर्षा से समुद्र को कई स्थानों पर पीछे धकेल दिया था और लोगों का कहना है कि इसी वजह से आज भी गोवा में बहुत से स्थानों का नाम वाणावली, वाणस्थली इत्यादि हैं। उत्तरी गोवा में हरमल के पास आज भूरे रंग के एक पर्वत को परशुराम के यज्ञ करने का स्थान माना जाता है।

इतिहास 

गोवा के लंबे इतिहास की शुरुआत् तीसरी सदी इसा पूर्व से शुरू होता है जब यहाँ मौर्य वंश के शासन की स्थापना हुई थी। बाद में पहली सदी के शुरुआत में इस पर कोल्हापुर के सातवाहन वंश के शासकों का अधिकार स्थापित हुआ और फिर बादामी के चालुक्य शासकों ने इस पर वर्ष 580 से 750 तक राज किया। इसके बाद के सालों में इस पर कई अलग अलग शासकों ने अधिकार किया। वर्ष 1312 में गोवा पहली बार दिल्ली सल्तनत के अधीन हुआ लेकिन उन्हें विजयनगर के शासक हरिहर प्रथम द्वार वहाँ से खदेड़ दिया गया। अगले सौ सालों तक विजयनगर के शासकों ने यहाँ शासन किया और 1469 में गुलबर्ग के बहामी सुल्तान द्वारा फिर से दिल्ली सल्तनत का हिस्सा बनाया गया। बहामी शासकों के पतन के बाद बीजापुर के आदिल शाह का यहाँ कब्जा हुआ जिसने गोअ-वेल्हा को अपनी दूसरी राजधानी बनाया।

1510 में, पुर्तगालियों ने एक स्थानीय सहयोगी, तिमैया की मदद से सत्तारूढ़ बीजापुर सुल्तान यूसुफ आदिल शाह को पराजित किया। उन्होंने वेल्हा गोवा में एक स्थायी राज्य की स्थापना की। यह गोवा में पुर्तगाली शासन का प्रारंभ था जो अगली साढ़े चार सदियों तक चला।

1843 में पुर्तगाली राजधानी को वेल्हा गोवा से पंजिम ले गए। मध्य 18 वीं शताब्दी तक, पुर्तगाली गोवा का वर्तमान राज्य सीमा के अधिकांश भाग तक विस्तार किया गया था।

भारत ने 1947 में अंग्रेजों से स्वतंत्रता प्राप्त की, भारत ने अनुरोध किया कि भारतीय उपमहाद्वीप में पुर्तगाली प्रदेशों को भारत को सौंप दिया जाए।किंतु पुर्तगाल ने अपने भारतीय परिक्षेत्रों की संप्रभुता पर बातचीत करना अस्वीकार कर दिया। पर 19 दिसंबर 1961 को, भारतीय सेना ने गोवा, दमन, दीव के भारतीय संघ में विलय के लिए ऑपरेशन विजय के साथ सैन्य संचालन किया और इसके परिणामस्वरूप गोवा, दमन और दीवभारत का एक केन्द्र प्रशासित क्षेत्र बना। 30 मई 1987 में केंद्र शासित प्रदेश को विभाजित किया गया था, और गोवा भारत का पच्चीसवां राज्य बनाया गया। जबकि दमन और दीव केंद्र शासित प्रदेश ही रहे।

भूगोल 
गोवा का क्षेत्रफल 3702 वर्ग किलोमीटर है। गोवा का अक्षांश और देशान्तर क्रमश: 14°53'54" और 73°40'33" E है। गोवा का समुद्र तट 132 किलोमीटर लम्बा है।
गोआ भारत का सबसे छोटा राज्य है।

अर्थ जगत 
गोवा का प्रमुख उद्योग पर्यटन है। पर्यटन के आलावा गोवा में लौह खनिज भी विपुल मात्रा में पाया जाता है जो जापान तथा चीन जैसे देशों में निर्यात होता है। गोवा मतस्य (मछली) उद्योग के लिए भी जाना जाता है लेकिन यहाँ की मछली निर्यात नहीं की जाती बल्कि स्थानीय बाजारों में बेची जाती है। यहाँ का काजू सउदी अरब, ब्रिटेन तथा अन्य यूरोपीय राष्ट्रों को निर्यात होता है। पर्यटन के वज़ह से बाकी उद्योग जो पर्यटन पर निर्भर करते है वो भी यहाँ पर जोर शोर से चालू हैं। गोवा में अभी तक सिर्फ़ एक ही विमानपत्तन है और दूसरा अभी बनने वाला है।

लोग और संस्कृति 
गोवा करीब करीब 450 साल तक पुर्तगाली शासन के अधीन रहा, इस कारण यहाँ यूरोपीय संस्कृति का प्रभाव बहुत महसूस होता है। गोवा की लगभग 60% जनसंख्या हिंदू और लगभग 28% जनसंख्या ईसाई है। गोवा की एक खास बात यह है कि, यहाँ के ईसाई समाज में भी हिंदुओं जैसी जाति व्यवस्था पाई जाती है।

गोवा के दक्षिण भाग में ईसाई समाज का ज्यादा प्रभाव है लेकिन वहाँ के वास्तुशास्त्र में हिंदू प्रभाव दिखाई देता है। सबसे प्राचीन मन्दिर गोवा में दिखाई देते है। उत्तर गोवा में ईसाइ कम संख्या में हैं इसलिए वहाँ पुर्तगाली वास्तुकला के नमूने ज्यादा दिखाई देते है।

संस्कृति की दृष्टि से गोवा की संस्कृति काफी प्राचीन है। 1000 साल पहले कहा जाता है कि गोवा "कोंकण काशी" के नाम से जाना जाता था। हालाँकि पुर्तगाली लोगों ने यहाँ के संस्कृति का नामोनिशान मिटाने के लिए बहुत प्रयास किए लेकिन यहाँ की मूल संस्कृति इतनी शक्तिशाली थी की वह ऐसा नहीं कर पाए।

गोवा की भाषा कोंकणी और लिपि देवनागरी है। हिन्दी का भी अधिकाधिक उपयोग होता है।

यातायात

बाहरी 
 हवाई: डैबोलिम विमानक्षेत्र यहाँ का घरेलू हवाई अड्डा है जो देश के सभी प्रमुख शहरों से जुड़ा है। अभी हाल के वर्षों में गोवा के लिये पणजी हवाई अड्डे से अंतर्राष्ट्रीय उड़ाने भी शुरू हुई हैं।
 सड़क: गोवा मुम्बई, बंगलोर से काफी अच्छी तरह जुड़ा हुआ है, इन शह्रों से गोवा के लिये सीधी लक्जरी बसें चलती हैं। इसके अलावा अन्य नजदीक के शहर भी आप सड़क द्वारा यहाँ से जा सकते हैं।
 रेल: जबसे यहाँ कोंकण रेलवे की शुरुआत हुई है गोवा भारत के पूर्वी तटीय शहरों से जुड़ गया है। कोंकण रेलवे अपनी गति और अच्छी सेवा के लिये पूरे भारत में मशहूर है। इसके अलावा गोवा आने के लिये देश के किसी भी बड़े स्टेशन से आप वास्को द गामा के लिये सीधी रेलगाड़ी पकड़ सकते हैं।

आंतरिक 
 टैक्सी बिना मीटर और मीटर वाली टैक्सियाँ यहाँ पर्यटकों को एक स्थान से दूसरे स्थान ले जाने का सबसे लोकप्रिय साधन है। बिना मीटर वाली टैक्सियों में यात्री पहले से भाड़े के बारे में तय करते हैं।
 बस गोवा में ज्यादातर बसे प्राईवेट चालकों द्वारा चलाई जाती हैं। आम तौर पर बसों में काफी भीड़ होती है। गोवा सरकार द्वारा यहाँ कदम्ब बस सर्विस चलाई जाती है जिनमें धीरे चलनेवाली बसों से लेकर द्रुत सेवा की लंबी दूरी की बसें शामिल होती हैं।
  नाव

पर्यटन 

वर्षा ऋतु के आगमन के साथ ही प्रकृति गोवा को कुछ ऐसा ही अलग, लेकिन अदभुत स्वरूप प्रदान करती है। यह स्थान शांतिप्रिय पर्यटकों और प्रकृति प्रेमियों को बहुत भाता है। गोवा एक छोटा-सा राज्य है। यहां छोटे-बड़े लगभग 40 समुद्री तट है। इनमें से कुछ समुद्र तट अंर्तराष्ट्रीय स्तर के हैं। इसी कारण गोवा की विश्व पर्यटन मानचित्र के पटल पर अपनी एक अलग पहचान है।

गोवा में पर्यटकों की भीड़ सबसे अधिक गर्मियों के महीनें में होती है। जब यह भीड़ समाप्त हो जाती है तब यहां शुरू होता है ऐसे सैलानियों के आने का सिलसिला जो यहां मानसून का लुत्‍फ उठाना चाहते हैं।

गोवा के मनभावन बीच की लंबी कतार में पणजी से 16 किलोमीटर दूर कलंगुट बीच, उसके पास बागा बीच, पणजी बीच के निकट मीरामार बीच, जुआरी नदी के मुहाने पर दोनापाउला बीच स्थित है। वहीं इसकी दूसरी दिशा में कोलवा बीच ऐसे ही सागरतटों में से है जहां मानसून के वक्त पर्यटक जरूर आना चाहेंगे। यही नहीं, अगर मौसम साथ दे तो बागाटोर बीच, अंजुना बीच, सिंकेरियन बीच, पालोलेम बीच जैसे अन्य सुंदर सागर तट भी देखे जा सकते हैं। गोवा के पवित्र मंदिर जिनसे श्री कामाक्षी, सप्तकेटेश्‍वर, श्री शांतादुर्ग, महालसा नारायणी, परनेम का भगवती मंदिर और महालक्ष्मी आदि दर्शनीय है। गोवा में किराए पर बाइक.

मांडवी नदी 
पणजी गोवा की राजधानी है। यहां के आधुनिक बाजार भी पर्यटकों को आकर्षित करते हैं। मांडवी नदी के तट पर बसे इस शहर में शाम के समय सैलानी रिवर क्रूज का आनन्द लेने पहुंचते हैं। मांडवी पर तैरते क्रूज पर संगीत एवं नृत्य के कार्यक्रम में गोवा की संस्कृति की एक झलक देखने को मिलती है।

गोवा के जिले 
गोवा में दो जिले हैं -

 उत्तर गोवा जिला
 दक्षिण गोवा जिला

खेल 
गोवा में सबसे लोकप्रिय खेल फुटबाल है। यहाँ कई लोकप्रिय फुटबाल क्लब हैं। इसके अलावा गोवा के बहुत से खिलाड़ी हाकी में भी दिलचस्पी रखते हैं। गोवा में अनेक समुद्रतट हैं . उन्मे से कुछ हैं बागा समुद्रतट, कलांगुते समुद्रतट, कोला समुद्रतट, इतियादी।

सन्दर्भ

इन्हें भी देखें
गोवा का इतिहास
गोवा मुक्ति संग्राम

बाहरी कड़ियाँ 
 
 Government of Goa official website
 Information on accommodation in hotels and resorts in Goa
 

 
भारत में पर्यटन

version: "{build}-{branch}"

# If we ever get a backlog larger than clone_depth, builds will fail
# spuriously. I do not think we will ever get 20 deep commits deep though.
clone_depth: 20

# We want to build everything, except for branches that are explicitly
# for messing around with Github Actions.
branches:
  except:
    - /devel-gha.+/


# We need a more up to date pip because Python 2.7 is EOL soon
init:
  - set PATH=C:\Python35;C:\Python35\Scripts;%PATH%


install:
  - ps: if (($env:CONFIGURATION) -eq "Debug" -And ($env:coverage) -eq "1" ) { pip --disable-pip-version-check install codecov }
  # This removes our changes to PATH. Keep this step last!
  - ps: if (($env:CONFIGURATION) -eq "Debug" -And ($env:coverage) -eq "1" ) { .\tools\misc\installOpenCppCoverage.ps1 }


before_build:
  # We need to modify PATH again, because it was reset since the "init" step
  - set PATH=C:\Python35;C:\Python35\Scripts;%PATH%
  - set CXXFLAGS=%additional_flags%
  # If we are building examples/extra-tests, we need to regenerate the amalgamated files
  - cmd: if "%examples%"=="1" ( python .\tools\scripts\generateAmalgamatedFiles.py )
  # Indirection because appveyor doesn't handle multiline batch scripts properly
  # https://stackoverflow.com/questions/37627248/how-to-split-a-command-over-multiple-lines-in-appveyor-yml/37647169#37647169
  # https://help.appveyor.com/discussions/questions/3888-multi-line-cmd-or-powershell-warning-ignore
  - cmd: .\tools\misc\appveyorBuildConfigurationScript.bat


# build with MSBuild
build:
  project: Build\Catch2.sln             # path to Visual Studio solution or project
  parallel: true                        # enable MSBuild parallel builds
  verbosity: normal                     # MSBuild verbosity level {quiet|minimal|normal|detailed}

test_script:
  - set CTEST_OUTPUT_ON_FAILURE=1
  - cmd: .\tools\misc\appveyorTestRunScript.bat


# Sadly we cannot use the standard "dimensions" based approach towards
# specifying the different builds, as there is no way to add one-offs
# builds afterwards. This means that we will painfully specify each
# build explicitly.
environment:
  matrix:
    - FLAVOR: VS 2019 x64 Debug Coverage Examples
      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
      examples: 1
      coverage: 1
      platform: x64
      configuration: Debug

    - FLAVOR: VS 2019 x64 Debug WMain
      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
      wmain: 1
      additional_flags: "/D_UNICODE /DUNICODE"
      platform: x64
      configuration: Debug

    - FLAVOR: VS 2019 x64 Debug Latest Strict
      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2019
      additional_flags: "/permissive- /std:c++latest"
      platform: x64
      configuration: Debug

    - FLAVOR: VS 2017 x64 Debug
      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
      platform: x64
      configuration: Debug

    - FLAVOR: VS 2017 x64 Release Coverage
      APPVEYOR_BUILD_WORKER_IMAGE: Visual Studio 2017
      coverage: 1
      platform: x64
      configuration: Debug

[package]

name = "log"
version = "0.4.33" # remember to update html_root_url
authors = ["The Rust Project Developers"]
license = "MIT OR Apache-2.0"
readme = "README.md"
repository = "https://github.com/rust-lang/log"
documentation = "https://docs.rs/log"
description = """
A lightweight logging facade for Rust
"""
categories = ["development-tools::debugging"]
keywords = ["logging"]
exclude = ["rfcs/**/*"]
rust-version = "1.71.0"
edition = "2021"

[package.metadata.docs.rs]
features = ["std", "serde", "kv_std", "kv_sval", "kv_serde"]

[features]
max_level_off   = []
max_level_error = []
max_level_warn  = []
max_level_info  = []
max_level_debug = []
max_level_trace = []

release_max_level_off   = []
release_max_level_error = []
release_max_level_warn  = []
release_max_level_info  = []
release_max_level_debug = []
release_max_level_trace = []

std = []

kv = []
kv_sval = ["kv", "value-bag/sval", "sval", "sval_ref"]
kv_std = ["std", "kv", "value-bag/error"]
kv_serde = ["kv_std", "value-bag/serde", "serde"]

# This is here to not break backwards compatibility with the implicit feature
# that enables support for serde based on the dependency name. Since we're now
# using serde_core, the implicit feature was renamed, this adds back an alias.
serde = ["serde_core"]

# Deprecated: use `kv_*` instead
# These `*_unstable` features will be removed in a future release
kv_unstable = ["kv", "value-bag"]
kv_unstable_sval = ["kv_sval", "kv_unstable"]
kv_unstable_std = ["kv_std", "kv_unstable"]
kv_unstable_serde = ["kv_serde", "kv_unstable_std"]

[dependencies]
serde_core = { version = "1.0", optional = true, default-features = false }
sval = { version = "2.16", optional = true, default-features = false }
sval_ref = { version = "2.16", optional = true, default-features = false }
value-bag = { version = "1.12", optional = true, default-features = false, features = ["inline-i128"] }

[dev-dependencies]
serde = { version = "1.0", features = ["derive"] }
serde_json = { version = "1.0" }
serde_test = { version = "1.0" }
sval = { version = "2.16" }
sval_derive = { version = "2.16" }
value-bag = { version = "1.12", features = ["test"] }

# NOTE: log doesn't actually depend on this crate. However, our dependencies,
# serde and sval, dependent on version 1.0 of the crate, which has problem fixed
# in 1.0.60, specifically in the following commit
# https://github.com/dtolnay/proc-macro2/commit/e31d61910049e097afdd3d27c37786309082bdcb.
# By defining the crate as direct dependency we can increase its minimal
# version making the minimal (crate) version CI happy.
proc-macro2 = { version = "1.0.63", default-features = false }

«Перестро́йка» — общее название, используемое для обозначения кардинальных перемен в экономической и политической структуре СССР, инициированных генеральным секретарём ЦК КПСС Михаилом Сергеевичем Горбачёвым в 1985—1991 годах. Началом перестройки считают 1987 год, когда на январском пленуме ЦК КПСС перестройка была объявлена новым государственным курсом. Перестройка в конечном счёте привела к распаду Советского союзного государства и фактически превращению Страны Советов из единого государства в исторический регион в Восточной Европе, Средней и Центральной Азии, Дальнем Востоке и Сибири с 15 международно признанными и несколькими непризнанными государствами, завершила и переосмыслила советскую эпоху и дала начало новой, постсоветской, современной эпохе с её либеральными реформами, частной собственностью, свободным рынком, правами человека, упрощённым визовым режимом, возвратом в некоторых местах к досоветскому, традиционному строю (обществу), пересмотру отношений со странами Востока и Запада, а также США, возрождению религиозной жизни и общин на местах и т. д.

Целью реформ была заявлена всесторонняя демократизация сложившегося в СССР общественно-политического и экономического строя, то есть иными словами переход к «народовластию» (досл. перевод понятия demokratia) на местах в самом широком смысле этого понятия. Планы экономических реформ разрабатывались ещё в 1983—1984 годах по поручению генерального секретаря ЦК КПСС Юрия Владимировича Андропова.

Впервые необходимость совершенствования существовавшей экономической системы — так называемого Ускорения — была провозглашена М. С. Горбачёвым на пленуме ЦК КПСС 23 апреля 1985 года. Однако эти меры касались только экономики, носили в основном административный характер и не затрагивали существа «развитого социализма». Кардинальная же реформа всей системы, включая политические изменения, началась после пленума ЦК КПСС 27 января 1987 года. Перестройка была обозначена в качестве задачи и как необходимое «преодоление эпохи застоя и обновление всех сторон жизни страны».

Важную роль в разработке идей перестройки играли видные учёные-обществоведы: Александр Николаевич Яковлев (ИМЭМО), Станислав Сергеевич Шаталин (ЦЭМИ), Татьяна Ивановна Заславская (ВЦИОМ), Евгений Максимович Примаков (ИМЭМО), Леонид Иванович Абалкин (Институт экономики АН СССР).

Оценки результатов перестройки в обществе разнятся. Цели реформ были достигнуты лишь частично: произошла демократизация общества, внедрена гласность, отменена цензура, достигнута разрядка в отношениях с Западом. В то же время в экономике СССР наступил спад, а с политической точки зрения итогами перестройки стали межэтнические конфликты, вооружённая борьба за власть и распад Советского Союза.

Термин 

15—17 мая 1985 года состоялась поездка генерального секретаря ЦК КПСС Горбачёва в Ленинград, где на встрече с активом Ленинградского горкома партии он впервые упомянул о необходимости перестройки общественно-политической жизни:

Слово было подхвачено СМИ и стало лозунгом начавшейся в СССР новой эпохи.

8 апреля 1986 года во время визита в Тольятти М. С. Горбачёв впервые употребил слово «перестройка», обозначив им политические и экономические перемены.

Историк Виктор Петрович Данилов отмечает, что «на языке того времени это понятие отнюдь не означало коренного изменения социально-экономических форм и сводилось к реорганизации некоторых хозяйственных функций и связей».

Этапы перестройки

Первый этап (март 1985 — январь 1987) 

11 марта 1985 года к власти в СССР пришёл Михаил Сергеевич Горбачёв, а уже 23 апреля на состоявшемся пленуме ЦК КПСС он заявил о необходимости реформирования системы под лозунгом «ускорения социально-экономического развития страны», то есть ускорения продвижения по социалистическому пути на основе эффективного использования достижений научно-технического прогресса, активизации человеческого фактора и изменения порядка планирования. Главной задачей стала интенсификация экономики и ускорение научно-технического прогресса. Ещё не шла речь о гласности, демократизации, социалистическом рынке и прочих вещах, которые позднее прочно войдут в обиход горбачёвской эпохи. В мае широко транслировавшаяся ленинградская речь Горбачёва взбудоражила жителей страны, и именно с этой речью у них стала ассоциироваться перестройка, хотя термин «перестройка» как лозунг в этот период не использовался и идеологического значения не имел; признавались отдельные недостатки существовавшей социально-экономической системы СССР и предпринимались попытки исправить их несколькими крупными кампаниями административного характера: ускорение развития народного хозяйства, автоматизация и компьютеризация, антиалкогольная кампания, «борьба с нетрудовыми доходами», введение Госприёмки за контролем производственного сектора, демонстрация борьбы с коррупцией.

Каких-либо радикальных шагов в этот период не предпринималось, внешне практически всё оставалось по-старому. В то же время в 1985—1986 годах была произведена замена основной массы старых кадров брежневского призыва на новую команду управленцев. Именно тогда в руководство страны были введены Александр Николаевич Яковлев, Егор Кузьмич Лигачёв, Николай Иванович Рыжков, Борис Николаевич Ельцин, Анатолий Иванович Лукьянов, Владимир Иванович Долгих и другие активные участники будущих событий. Николай Рыжков вспоминал (в газете «Новый Взгляд», 1992): «В ноябре 82-го года меня — совершенно неожиданно — избрали секретарём ЦК, и Андропов ввёл меня в команду, готовившую реформы. Туда входили и Горбачёв, Долгих… Мы стали разбираться с экономикой, а с этого началась перестройка в 85-м году, где практически были использованы итоги того, что сделали в 1983—1984-х годах. Не пошли бы на это — было бы ещё хуже».

Состоявшийся в феврале — марте 1986 года XXVII съезд КПСС изменил программу партии: провозглашался курс на «совершенствование социализма» (а не «построение коммунизма», как ранее); предполагалось к 2000 году удвоить экономический потенциал СССР и предоставить каждой семье отдельную квартиру (программа «Жильё—2000»).

Внешняя политика СССР в 1985—1986 годах продолжала оставаться достаточно жёсткой, несмотря на наметившееся сразу после прихода к власти Горбачёва небольшое потепление в отношениях с США и Западом. Существенный сдвиг на международной арене произошёл только осенью 1987 года, когда СССР согласился пойти на серьёзные уступки при подготовке соглашения об РСМД.

Второй этап (январь 1987 — июнь 1989) 
К концу 1986 — началу 1987 годов горбачёвская команда пришла к выводу, что административными мерами ситуацию в стране не изменить и предприняла попытку реформирования системы в духе демократического социализма. Этому шагу способствовали два удара по советской экономике в 1986 году: резкое падение цен на нефть и Чернобыльская катастрофа.

Новый этап начался с январского пленума ЦК КПСС 1987 года, на котором была выдвинута задача коренной перестройки управления экономикой, и характеризовался он началом масштабных реформ во всех сферах жизни советского общества (хотя отдельные меры начали приниматься ещё в конце 1986 года, например, Закон «Об индивидуальной трудовой деятельности»):
 В общественной жизни провозглашается политика гласности — смягчение цензуры в СМИ и снятие запретов на обсуждение тем, которые раньше замалчивались (в первую очередь сталинские репрессии, а также секс вообще и проституция в частности, наркомания, бытовое насилие, подростковая жестокость и т. д.).
 
 В экономике узаконивается частное предпринимательство в форме кооперативов (хотя слова «предпринимательство» и «частная собственность» произносить вслух пока не осмеливаются, кооперативы вводятся как элемент рынка в существующую социалистическую модель), начинают активно создаваться совместные предприятия с зарубежными компаниями.
 В международной политике основной доктриной становится «Новое мышление» — курс в сторону отказа от классового подхода в дипломатии и улучшения отношений с Западом.

В октябре 1987 года Горбачёв заявил, что перестройка рассчитана на "16–20 лет"

Выдвигаются лозунги о необходимости избавить социализм от «деформаций», о возвращении к «ленинским нормам», «идеалам Октября» и «социализму с человеческим лицом» посредством демократизации всех сторон жизни общества, реформирования политических институтов. В этот период были опубликованы почти все запрещённые ранее произведения Василия Гроссмана, Андрея Платонова, Евгения Замятина, Михаила Булгакова, Бориса Пастернака; резонанс в обществе вызвали новые книги: романы Чингиза Айтматова «Плаха», Анатолия Рыбакова «Дети Арбата», Владимира Дудинцева «Белые одежды», сборник рассказов Татьяны Толстой «На золотом крыльце сидели…». Вновь встал вопрос о сталинских репрессиях и реабилитации их жертв. В сентябре 1987 г. была создана комиссия Политбюро ЦК КПСС по реабилитации, которую возглавил Александр Николаевич Яковлев. Открытие в конце 1987 года Оптиной пустыни и Толгского монастыря и относительно публичное празднование 1000-летия крещения Руси в 1988 году воспринимались как знаки перемен в политике государства в отношении церкви.

Часть населения (в основном молодёжь и либеральная интеллигенция — «шестидесятники», заставшие предыдущую, хрущёвскую либерализацию) охвачена эйфорией от начавшихся после двух десятилетий застоя перемен и невиданной по прежним меркам свободы. Общественная апатия начала 80-х сменяется верой в светлое будущее.

Вместе с тем, с 1988 года в стране начинает постепенно нарастать общая неустойчивость: ухудшается экономическое положение, появляются сепаратистские настроения на национальных окраинах, вспыхивают первые межнациональные столкновения (Карабах).

Третий этап (июнь 1989 — сентябрь 1991) 
Заключительный этап, в этот период происходит резкая дестабилизация обстановки в стране. После I Съезда народных депутатов начинается противостояние коммунистической партии с возникшими в итоге демократизации общества новыми политическими группировками. Изначально начатые по инициативе сверху, во второй половине 1989 года перемены выходят из-под контроля властей. Трудности в экономике перерастают в полномасштабный кризис: в 1989 году экономический рост резко замедляется, в 1990-м сменяется падением, а к концу 1991-го страна оказывается на грани экономического коллапса. Происходит катастрофический обвал жизненного уровня населения: реальностью советского общества начала 90-х становятся массовая нищета и безработица. Достигает апогея хронический товарный дефицит: пустые полки магазинов становятся символом рубежа 1980—1990-х гг, с 1991 г. Европа активно помогает СССР в поставках гуманитарной помощи. Перестроечная эйфория в обществе сменяется разочарованием, неуверенностью в завтрашнем дне и массовыми антикоммунистическими настроениями. Усиливается эмиграция за рубеж. С 1990 года основной идеей становится уже не «совершенствование социализма», а построение демократии западного образца и рыночной экономики капиталистического типа.

В 1987—1991 гг. социально-экономический строй СССР начинает приобретать черты капитализма: легализуется частная собственность, образуются фондовый и валютный рынки, кооперация, СП и ИТД (индивидуально-трудовые доходы) начинают принимать форму бизнеса западного типа. «Новое мышление», половинчатые реформы, и политика ускорения (1985—1987) на международной арене сводится к односторонним уступкам Западу, в итоге чего СССР утрачивает многие свои позиции и фактически перестаёт быть сверхдержавой, ещё несколько лет назад контролировавшей половину мира. В РСФСР c июня 1988 года после 19-й партконференции КПСС и других республиках Союза к власти приходят сепаратистски настроенные силы — начинается «парад суверенитетов» — провозглашается независимость республик. Середина 80-начало 90-х гг. в политике ознаменовалось кровавыми боестолкновениями:
Декабрь 1986 г. — Алма-Ата (Казахстан);
Декабрь 1987 — февраль 1988 г. — Карабах (Армения и Азербайджан);
Апрель 1989 г. — Тбилиси (Грузия);
Январь 1990 г. — Баку (Азербайджан);
Январь 1991 г. — Рига (Латвия), Вильнюс (Литва).

17 марта 1991 г. в проведённом общесоюзном референдуме за сохранение единства СССР высказалось около 77 %, в нём участвовало 9 из 15 республик державы, в апреле — новый акт Союзного Договора перенесли на 20 августа. За сутки до подписания акта в Москву были введены войска — начался 3-дневный августовский путч 1991 г, после которого уже не было ни малейшего шанса на спасение СССР.
1 декабря 1991 года Украина заявила о своей независимости. 7-8 декабря в резиденции Вискули (Минск) лидеры РСФСР, Украины и Белоруссии подписали Беловежскую Декларацию о создании СНГ, вступившую в силу после Алма-Атинских переговоров (21.12.1991), куда вошли все 11 республик бывшего СССР.
Итогом такого развития событий стали ликвидация власти КПСС, Августовский кризис 1991 года и распад Советского Союза в августе — декабре 1991 года.

Четвёртый этап — окончание перестройки или пост-Перестройка (сентябрь — декабрь 1991 г.) 

Период между провалом ГКЧП и юридическим оформлением распада СССР к Перестройке обычно относить не принято; это своего рода «безвременье», когда, с одной стороны, единое государство формально ещё продолжало существовать, а с другой — советская история подошла к своему завершению и окончательная ликвидация СССР стала лишь вопросом времени. В этот период происходит демонтаж коммунистического строя и всей системы государственной власти в Советском Союзе. К концу 1991 года происходит фактический коллапс союзной экономики. Республики Прибалтики де-юре выходят из состава СССР, остальные республики также берут курс на независимость. Деятельность КПСС сначала приостанавливается, а затем окончательно запрещается. Вместо полноценных органов власти создаются суррогатные неконституционные структуры (Госсовет, КОУНХ, МЭК). Вся полнота реальной власти переходит с союзного на республиканский уровень. Работа над новым союзным договором продолжается до ноября, однако чем дальше, тем очевиднее становится стремление республиканских элит, почувствовавших вкус реальной власти, к окончательному размежеванию и обособлению. 8 декабря в резиденции «Вискули» в Беловежской пуще лидеры России, Украины и Белоруссии провозглашают, что Советского Союза больше нет. Центральная власть во главе с Горбачёвым парализована и уже ничего не может противопоставить этим действиям. 25 декабря 1991 года Михаил Горбачёв слагает с себя полномочия Президента Союза Советских Социалистических Республик, и 26 декабря 1991 года СССР перестаёт существовать.

Некоторые вехи

1985 год 

Наиболее ранней вехой в начале «Перестройки» является приход в марте 1985 года к власти М. С. Горбачёва, главного проводника преобразований в СССР.
 для широких масс населения Советского Союза перестройка началась с транслировавшейся широко по всей стране Ленинградской речи Горбачёва в мае 1985 года; именно эту речь можно считать началом перестройки
  — Постановление Совета министров СССР «О мерах по преодолению пьянства и искоренению самогоноварения».

1986 год 
  — Авария на Чернобыльской атомной электростанции.
  — Постановление Совета министров СССР «О мерах по усилению борьбы с нетрудовыми доходами».
 Сентябрь 1986 года — впервые президент Аргентины (Рауль Альфонсин) посетил СССР.
  — Верховный Совет СССР принял Закон СССР «Об индивидуальной трудовой деятельности».
 17—18 декабря — события в Алма-Ате

1987 год 
  — Первая несанкционированная демонстрация неправительственной и некоммунистической организации — общества «Память» в Москве.
  — Пленум ЦК КПСС рассмотрел вопрос «О задачах партии по коренной перестройке управления экономикой».
 
 Принят закон СССР «О государственном предприятии (объединении)».
 Принят «Закон о порядке обжалования в суд неправомерных действий должностных лиц, ущемляющих права гражданина»
 август 1987 года — Впервые разрешена безлимитная подписка на газеты и журналы.
 декабрь 1987 года — по решению Политбюро ЦК КПСС и Совета Министров СССР был создан Всесоюзный центр изучения общественного мнения (ВЦИОМ).

1988 год 
  — статья Нины Александровны Андреевой в газете «Советская Россия» — «Не могу поступаться принципами»
 Март 1988 года — впервые президент Уругвая (Хулио Мария Сангинетти) посетил СССР.
  — Принят закон «О кооперации в СССР».
 5—18 июня 1988 года — Всесоюзные торжественные мероприятия, приуроченные к 1000-летнему юбилею принятия христианства на Руси.
  —  — XIX Всесоюзная конференция КПСС, принявшая резолюции «О некоторых неотложных мерах по практическому осуществлению реформы политической системы страны», «О ходе реализации решений XXVII съезда КПСС и задачах по углублению перестройки», «О демократизации советского общества и реформе политической системы», «О борьбе с бюрократизмом», «О межнациональных отношениях», «О гласности», «О правовой реформе».
  — Указы Президиума ВС СССР «О порядке организации и проведения собраний, митингов, уличных шествий и демонстраций в СССР» и «Об обязанностях и правах внутренних войск МВД СССР при охране общественного порядка».
  — в Чимкенте (Казахская ССР) зарегистрирован первый в СССР кооперативный банк («Союз-банк»), его уставной капитал составил 1 млн рублей.
  — Начался суд над Юрием Михайловичем Чурбановым (5 сентября — 30 декабря).
  — На Пленуме ЦК КПСС проходит крупнейшая со сталинских времён «чистка» Политбюро.
 Октябрь 1988 года — впервые президент Бразилии (Жозе Сарней) посетил СССР.

1989 год 
 январь 1989 года — Началось первое свободное выдвижение кандидатов в народные депутаты СССР.
  — завершился вывод советских войск из Афганистана.
  — впервые советский хоккеист (Сергей Пряхин) официально принял участие в матче НХЛ.
  — разгон оппозиционного митинга у дома правительства ГССР в Тбилиси.
  —  — Визит главы СССР и КПСС М. Горбачёва в КНР. Начало процесса нормализации советско-китайских отношений.
  — Верховный Совет Литовской ССР принял декларацию о государственном суверенитете.
  —  — Первый съезд народных депутатов СССР.
  — Верховный Совет Латвийской ССР принял декларацию о государственном суверенитете.
  — Верховный Совет Эстонской ССР объявил незаконным присоединение республики к СССР в 1940 году.
 1989 год — Университеты и ВУЗы СССР начали готовить специалистов по специальности «социология».

1990 год 
 Январь 1990 года — армянские погромы в Баку; ввод советских войск в город Баку с целью подавления политической оппозиции, закончившееся гибелью более сотни жителей города, в основном азербайджанцев.
  — МИД Чехословакии потребовало вывести войска СССР с территории страны до конца 1990 года.
  — МИД Венгрии потребовало вывести войска СССР с территории страны до конца 1990 года.
  — На первых свободных выборах в Литве одержало победу движение «Саюдис».
  — Начало вывода советских войск из Чехословакии.
  — В итоге советско-монгольских переговоров принято решение о выводе советских войск из Монголии до 1992 года.
  — В результате выборов в Верховный Совет РСФСР избирательный блок «Демократическая Россия» получила около 20 % голосов избирателей.
  — Принят «Закон о собственности в СССР».
 Весна 1990 года — Эстония, Литва и Латвия, в одностороннем порядке, провозглашают независимость и объявляют о выходе из состава СССР. Начинается процесс распада государства на независимые республики.
  — На первых свободных выборах в ГДР одержало победу движение «Альянс за Германию».
  — На первых свободных выборах в Венгрии одержало победу движение «Венгерский демократический форум».
  — В результате переговоров сандинистского правительства Никарагуа и «контрас» подписано соглашение о немедленном прекращении огня.
  — Встреча министров иностранных дел Великобритании (Дуглас Хёрд), СССР (Эдуард Шеварднадзе), США (Джеймс Бейкер), Франции (Ролан Дюма), ГДР (Маркус Меккель) и ФРГ (Ганс-Дитрих Геншер) по проблеме объединения Германии.
  — Борис Николаевич Ельцин избран председателем Верховного Совета РСФСР.
  — СССР и США подписали соглашение об уничтожении и запрещении производства химического оружия и о подготовке многосторонней конвенции о запрещении химического оружия.
  — Первая встреча президента СССР Михаила Горбачёва и президента Южной Кореи Ро Дэ У, положившая начало процессу нормализации отношений между СССР и Южной Кореей.
  — На первых свободных выборах в Чехословакии одержало победу движение «Чешский гражданский форум».
  — съезд народных депутатов принимает Декларацию о государственном суверенитете России.
  — Принят «Закон о печати в СССР». Авторы: Михаил Александрович Федотов, Юрий Михайлович Батурин и Владимир Львович Энтин.
  — М. С. Горбачёв подписал президентский указ «О восстановлении прав всех жертв политических репрессий 20-50-х годов». Этим указом репрессии по политическим, социальным, национальным, религиозным и другим мотивам были признаны незаконными, а все права граждан, подвергшихся этим репрессиям, восстанавливались.
  — М. С. Горбачёв подписал президентский «Указ о возвращении советского гражданства лицам, его лишённым».
  — Принятие Закона СССР «О свободе совести и религиозных организациях».
  — Объединение Германии.
  — В Париже подписан договор об обычных вооружённых силах в Европе.
  — В Париже подписана Парижская хартия.

1991 год 
  — На референдуме в Литве по вопросу о независимости государства из 84,5 % имевших право голоса граждан за независимость высказались 90,5 %, против — 6,5 %.
  — На референдумах в Эстонии и Латвии по вопросу о независимости государства, в Эстонии из 82,68 % имевших право голоса граждан за независимость высказались 77,83 %, в Латвии из 87,57 % имевших право голоса граждан за независимость высказались 73,8 %.
  — Прошёл общесоюзный референдум о судьбе СССР. В России за сохранение союзного государства высказались 77 % участвовавших в голосовании, 26,4 % высказались против.
  — Верховный Совет Грузии принял Акт о восстановлении государственной независимости.
  — Завершился вывод советских войск из Чехословакии.
  — В Эфиопии войска Революционно-демократического фронта эфиопских народов заняли Аддис-Абебу.
  — В Лиссабоне президент Анголы Жозе Эдуарду душ Сантуш и лидер повстанческого движения УНИТА Жонаш Савимби подписали пакет соглашений о мирном урегулировании.
  — Выборы президента в РСФСР. Борис Николаевич Ельцин избран президентом. Он победил в первом туре с 57,3 % голосов.
  — Завершился вывод советских войск из Венгрии.
  —  — В Словении произошли вооружённые столкновения между югославской союзной армией и словенскими силами территориальной обороны.
  — Представители 9 государств — членов СЭВ подписали в Будапеште соглашение о роспуске организации.
  — На заседании Политического консультативного комитета ОВД в Праге 6 государств-членов приняли решение о роспуске организации.
  — В Москве в ходе визита президента США Джорджа Буша-старшего подписан советско-американский договор о сокращении и ограничении стратегических наступательных вооружений (СНВ-1).
  —  — Августовский путч. Ввод танков в Москву, штурм баррикад на Садовом кольце, 3 человека погибли. 22 августа вводится новый государственный флаг — Российский триколор в противовес советскому красному знамени с серпом и молотом.
  — Парламент Эстонии объявил о введении в действие Декларации независимости.
  — Парламент Латвии объявил о введении в действие Декларации независимости.
  — Верховный Совет Украины принял Декларацию независимости с условием её подтверждения на референдуме 1 декабря 1991 г.
  — Верховный Совет Беларуси принял Декларацию независимости.
  — Парламент Молдовы принял Декларацию независимости.
  — Верховный Совет Азербайджана принял решение о восстановлении государственной независимости на основе Акта 1918 г.
  — Верховный Совет Кыргызстана принял Декларацию независимости.
  — Верховный Совет Узбекистана принял Декларацию независимости.
  — Государственный Совет СССР признал независимость Литвы, Латвии и Эстонии.
  — В югославской Республике Македонии в ходе референдума большинство голосовавших высказались за независимость.
  — Верховный Совет Таджикистана принял Декларацию независимости.
  — Литва, Латвия и Эстония приняты в СБСЕ.
  — Литва, Латвия, Эстония, КНДР, Республика Корея, Микронезия и Маршалловы острова стали членам ООН.
  — Верховный Совет Армении принял Деклара

は、無生物と区別される属性、つまり「生命」を備えているものの総称。そしてその「生命」とは、生物の本質的属性として生命観によって抽象されるものであり、その定義はなかなか難しいものとなっている。とも。

定義 

「生命現象を示すもの」というのが一応の定義であるが、これ以外の定義も存在し、統一は困難であるとされる。生物が持ち、無生物が持たない能力や特徴としては「自己増殖能力」「エネルギー変換能力」「自己と外界との明確な隔離」が挙げられ、これに「進化する能力」を加えることも多い。また、生物は外界とのやりとりを絶やすことのない開放系を取りながら、恒常性（ホメオスタシス）を維持する能力を持ち、常に変化する。生物はすべて細胞を基礎としており、細胞によって構成されていないウイルスなども寄生する細胞がなくては増殖できない。

動物・菌類・植物・原生生物・古細菌・細菌などの総称。多くの場合ウイルスを含めないが、立場によっては含めることもある。なお、『岩波生物学辞典』ではウイルスは生物であるか断言できないとしている
。

生物の分類 

現在生きている生物は少なくとも300万種、おそらくは1000万種に達するが、これらをその特徴に応じて大小の分類階級に所属させ、それによって生物を整理し秩序を与えることを分類という。分類階級のうち、次に掲げるものは必ず設置される（基本分類階級）。すなわち大きいほうから順に界、門、綱、目、科、属である。

歴史的に最も古くは生物は植物と動物からなるとした二界説（植物界、動物界）があり、その後の生物観の進展とともに、三界説、五界説、八界説などが登場した。一般によく知られる五界説ではモネラ界、原生生物界、植物界、菌界、動物界に分類する。しかし近年では分子系統学の成果を反映して、界よりさらに上位の枠組みとしてドメインが設けられており、細胞特性に従い生物全体を真核生物、細菌（バクテリア）、古細菌（アーキア）に分類する三ドメイン説が一般的になってきている。三ドメイン説においては、動物、植物、菌類、原生生物はすべて真核生物という単一のドメインに属する。一方、モネラ界は細菌および古細菌という2つの大きなドメインに分割される。見た目の大きさという点では、細菌および古細菌はすべて微生物であるため、真核生物と違って日常で目にすることはまずないが、生態の多様さという点では細菌および古細菌ドメインは真核生物よりはるかに大きい。

また近年では、真核生物が細菌および古細菌が融合して誕生したとする説が有力となりつつあり（参照: 真核生物#起源）、この場合、地球上には本来２つのドメイン（細菌と古細菌）しか存在しなかったことになる。ちなみに古細菌は、かつて細菌よりも起源が古い可能性が示唆されたため付けられた名前であるが、実際のところは、細菌と古細菌は両者とも同等に古い起源をもっている。

生物相互の関係 
上でも説明したが地球上には少なくとも300万種の生物が生きていると言われており、それらの多様な生物の間には複雑な関係が成立している。たとえば寄生、共生などという関係があり、また動物が植物を食べるという関係や、ある生物が天敵に捕食される、というかなり直接的な関係もあり、ほかにもある生物が花粉を媒介する、といった関係もある。

こうして生物どうしは互いに「他の生物にとっての環境」となっている。これを <<生物的環境>> という。ある地域に共存している生物種の間ではさまざまな関係が成立しており、どの生物種に関しても、<<生物的環境>>つまり他のさまざまな生物との関係を分析してやっとその生活が理解できるようになる。

この生物相互の関係は、地球環境が変化するとともに変化してきた。そして生物が地球の環境にも影響を与えている（生物が地球の環境の影響を受け、また地球の環境を変化させていることは次節で解説）。

生物と地球環境 
生物が現れる前は、二酸化炭素が多くを占める構成であったと推測されている。その温室効果によって地表の温度も高かった。

そんな状態だった地球上に、（諸説あるが）今から35～24億年前ころにシアノバクテリア（藍藻）が登場し、光合成を行うようになり、生み出した酸素を海水中へ放出しはじめ、地球上に大量の酸素が形成されるようになった。（地球における大量の酸素の出現は「大酸化イベント」という。開始した時期や活発化した時期に関しては諸説ある。「大酸化イベント」の記事にグラフも掲載。）　

生物が出現し、特に光合成による有機物の生成（炭素固定）とそれに伴う（分子状）酸素の放出、生物由来の石灰岩の生成がなされた結果、今のような酸素が多く含まれた窒素主体の大気組成となった（ただし、大気組成の変化は生物だけによるものではない。地球の大気#地球大気の「進化」も参照のこと）

また、酸素の多い大気になったことによって、オゾン層が形成され、生物にとって有害な宇宙線や紫外線の遮断がなされ、生物の陸上進出が可能になった。また、海水中の酸素が増えることによって、海水に溶け込んだ鉄が酸化鉄となって沈降し鉄鉱床を堆積させた。

2021年現在の地球の大気組成は、窒素が78%、酸素が21%、アルゴン0.93%、二酸化炭素が0.041%という構成になっている。

地球上の全ての生物の共通の祖先があり（原始生命体・共通祖先）、その子孫達が増殖し複製するにつれ遺伝子に様々な変異が生じることで進化がおきたとされている。結果、今日の生物多様性が生まれ、お互いの存在(他者)や地球環境に依存しながら、相互に複雑な関係で結ばれる生物圏を形成するにいたっている。ガイア理論（ガイア仮説）では、このような地球を「自己調節能力を持ったひとつの巨大な生命体」とみなした。

生物を成り立たせる生体物質 

水、タンパク質、脂質、多糖、核酸は生物の主要な構成成分である。生きているという状態は、無数の化学反応の総和であるという見方もできる。これら化学反応がおこる場を提供しているのが水である。生物は水の特殊な物性に多くの事を依存しており、極めて重要でかつ主要な構成成分である。どの生物でも、体の約70％は水であり、その他の物質が30％ほどを占める。

タンパク質は量の上で多数を占める生体高分子である。20種類のアミノ酸が通常100 - 1000個重合してタンパク質となる。あるものは細胞を支える骨格となり、あるものは生体内化学反応の触媒となる（酵素）。

必要なタンパク質を必要な場所で産生するための情報を記録する生体高分子が核酸である。この情報は遺伝によって次の世代に引き継がれる。

ロバート・フックがコルクを顕微鏡観察して見出した小さな区画に小部屋（cell＝細胞）と名付けたように、細胞とはある区画化された空間を指す。この区画をしているのが細胞膜であり、脂質がその主要な成分である。脂質はエネルギーとして効率が良く、また貯蔵するのによい物質でもある。

生物は区画された空間ではあるが、完全に外界から遮断されているわけではない。外部からエネルギーを取り入れ内部で消費し、化学反応で物質を作り出す。生物間でのエネルギーの流通に炭水化物（糖）は重要であり、主に植物が光合成によって生産している。

地球外生命体 
地球以外の天体に生物が発見された事例は記録されていない。しかし、地球のそれと同様の生物あるいは全く異なった性質の生物が地球以外の場所に存在する可能性は否定できない。太陽系内においても、火星には生命が存在する可能性が指摘されている。2018年7月には、イタリア国立宇宙物理学研究所などからなる国際天文学チームがマーズ・エクスプレスの観測データに基づき、「火星の南極の厚さ1.5kmの氷床の下に幅20kmにわたって水とみられる層が存在する」との論文を発表した。この地底湖は、液体の状態が維持されていると推測されている。研究チームは、「生命にとって厳しい環境ながら単細胞生物が生存している可能性がある」と述べている。

系外惑星としては、2007年に発見されたグリーゼ581cに生物が生存可能な環境の存在が期待されたことがある（その後の研究によるとこの天体はハビタブルゾーンの外にある）。2008年現在、太陽系外における地球型惑星の観測成果も少しずつあがってきている。

有機物以外を構成要素とする生物も想定される。このような仮想理論は「代わりの生化学」と呼ばれている。とくにケイ素は、炭素と同じ族に含まれ化学的性質も似ていることから、「代わりの生化学」のベースとして比較的頻繁に言及される（ケイ素生物）。

サイエンス・フィクションの世界では、ガス・電磁波から成る生物などが登場する。他に純粋知性、精神あるいは物質によらない意識が登場するが、現在のところ物質的な実体に依拠しない意識は確認されていない。また多くの宗教で霊と呼ばれる形態の生物の存在を想定している。

ギャラリー

脚注

注釈

出典

参考文献

関連項目 

 生物学、生物の分類
 無生物
 伝説の生物一覧
 Wikipedia:多数の言語版にあるが日本語版にない記事/生物

外部リンク 
 

地球史

Eventi

Africa 
 In Ifriquya c'è la dinastia degli Ziridi

Asia 
 Dinastia dei Ghaznavidi in Afghanistan

Medio Oriente 
 Inizio del periodo fatimida in Egitto (fine nel 1711). La capitale dei Fatimidi è spostata al Cairo. La città raggiunge i 500 000 abitanti tra il X e l'XI secolo.
 I Fatimidi annettono la Siria, occupano Damasco ma si scontrano alla riconquista bizantina di Giovanni I Zimisce e alle divisioni arabe.

Europa 
 Guerra russo-bizantina: l'esercito russo di Sviatoslav dopo avere combattuto i bulgari per conto dei Bizantini, devasta i dintorni di Costantinopoli nel 970. Poi assediano Edirne ma sono sconfitti da Barda Sclero durante la battaglia di Arcadiopoli. L'esercito è in seguito scacciato dai Balcani da un'operazione terrestre e fluviale di Giovanni I Zimisce, che annette la Bulgaria orientale (971)
 In seguito alle ambasciate di Liutprando di Cremona e alle negoziazioni di Pandulfo Testadiferro a Costantinopoli, il basileus Giovanni I Zimisce e l'imperatore Ottone I concludono la pace nel sud Italia. L'imperatore bizantino riconosce la dignità di Ottone, e il futuro Ottone II sposerà una principessa bizantina.
 Battaglia di Tourtour dei provenzali contro la fortezza di Frassineto, un rifugio sarracino.
 La Boemia è cristianizzata.

Scoperte, arte, economia 
 Il califfo fatimida fa costruire un osservatorio al Cairo dove lavora Ibn Yunus

Personaggi

Note

Altri progetti 

 08

Sa 
Ferdinand von Saar (1833–1906)
Umberto Saba (1883–1957)
Robert Sabatier (1923–2012)
Ernesto Sabato (1911–2011)
Rolf D. Sabel (* 1949)
Martin Sabrow (* 1954)
Mário de Sá-Carneiro (1890–1916)
Leopold von Sacher-Masoch (1836–1895)
Hans Sachs (1494–1576)
Nelly Sachs (1891–1970)
Jonathan Sacks (1948–2020)
Oliver Sacks (1933–2015)
Vita Sackville-West (1892–1962)
Donatien-Alphonse-François, Marquis de Sade (1740–1814)
Abu’Abdellah Mosharrefo’d–Din ben Mosleho’d–Din Sa’di (zwischen 1213 und 1219 – 1292)
Douglas Sadownick (* 1959)
Rüdiger Safranski (* 1945)
Carl Sagan (1934–1996)
Françoise Sagan (1935–2004)
Hans Sahl (1902–1993)
Marshall Sahlins (1930–2021)
Edward Said (1935–2003)
SAID (1947–2021)
Angela Saini (* 1980)
Assoto Saint (1957–1994)
Antoine de Saint-Exupéry (1900–1944)
At-Tayyib Salih (1929–2009)
J. D. Salinger (1919–2010)
James Sallis (* 1944)
Sally Salminen (1906–1976)
Ernst von Salomon (1902–1972)
Sallust (86–35 v. Chr.)
Felix Salten (1869–1945)
James Salter (1925–2015)
Gaston Salvatore (1941–2015), CL / D
R. A. Salvatore (* 1959)
Lydie Salvayre (* 1948), FR
Jewgenij Samjatin (1884–1937)
Jeffrey L. Sammons (1936–2021), US
José Luis Sampedro (1917–2013), ES
Clara Sánchez (* 1955), ES
Rafael Sánchez Ferlosio (1927–2019), ES
George Sand (1804–1876)
Margit Sandemo (1924–2018)
Gregor Sander (* 1968)
Maurice-Yves Sandoz (1892–1958), CH
Cícero Sandroni (* 1935), BR
Edoardo Sanguineti (1930–2010)
Eric San Juan (* 1973), US
José Saramago (1922–2010)
Stephan Sarek (* 1957), D
Ken Saro-Wiwa (1941–1995)
William Saroyan (1908–1981)
Nathalie Sarraute (1900–1999), FR
Joseba Sarrionandia (* 1958)
Andrew Sarris (1928–2012), US
Joachim Sartorius (* 1946)
Jean-Paul Sartre (1905–1980)
Saskia Sassen (* 1949)
Alfonso Sastre (1926–2021), E
John Saul (* 1942)
Annie Saumont (1927–2017)
Dan Savage (* 1964)
Jon Savage (* 1953)
Richard Henry Savage (1846–1903)
Walter Savage Landor (1775–1864)
Sam Savage (1940–2019)
Roberto Saviano (* 1979)
Alberto Savinio (1891–1952)
Dorothy L. Sayers (1893–1957)
Şara Sayın (1926–2017)
Steven Saylor (* 1956)

Sc 
Giorgio Scerbanenco (1911–1969)
Andrea Schacht (1956–2017)
Carlo Schäfer (1964–2015)
Rafik Schami (* 1946)
Sydney Schanberg (1934–2016)
Frieda Schanz (1859–1944)
Frank Schätzing (* 1957), D
Karl Herbert Scheer
Paul Scheerbart (1863–1915)
Leopold Schefer (1784–1862)
Joseph Victor von Scheffel (1826–1886)
Ursel Scheffler (* 1938), D
Wolfgang Scheffler (1929–2008), D
Susanne Scheibler
Jonathan Schell (1943–2014), US
Peter Schellenbaum (1939–2018), CH
Bernardin Schellenberger (* 1944), D
Caroline Schelling (1763–1809)
Friedrich Schelling (1775–1854)
Andreas Schendel (* 1971), D
Daniela Schenk (* 1964), CH
Johannes Schenk (1941–2006)
Joan Schenkar (* 1952), USA
Max von Schenkendorf (1783–1817)
Walter Schenker (1943–2018)
Karl Adolf Scherer (1929–2008)
Marie-Luise Scherer (1938–2022), D
René Schérer (1922–2023), FR
Ronald M. Schernikau (1960–1991), D
Manfred Scheuch (1929–2016), AT
Mario Scheuermann (1948–2015), D
Christian Scheuß (* 1966), D
Jakob van Schevichaven (1866–1935)
Taras Grigorjewitsch Schewtschenko (1814–1861)
Alfred Schickel (1933–2015)
Gotthard B. Schicker (1946–2017)
Claudia Beate Schill (1952–2022)
Friedrich Schiller (1759–1805)
Helmut Schiller (* 1938), D
Lawrence Schimel (* 1971), US
Jochen Schimmang (* 1948)
Annemarie Schimmel (1922–2003)
Roland Schimmelpfennig (* 1967)
Ferdinand von Schirach (* 1964)
Frank Schirrmacher (1959–2014)
Wolfgang Schivelbusch (1941–2023)
Peter Schjeldahl (1942–2022)
Johannes Schlaf (1862–1941)
Evelyn Schlag (* 1952)
Einar Schleef (1944–2001)
August Wilhelm Schlegel (1767–1845)
Dorothea von Schlegel (1763–1839)
Friedrich von Schlegel (1772–1829)
Johann Elias Schlegel (1719–1749)
Carl Ludwig Schleich (1859–1922)
Friedrich Schleiermacher (1768–1834)
Klaus Schlesinger (1937–2001)
Christoph Schlingensief (1960–2010), D
Bernhard Schlink (* 1944), D
Joachim Schlör (* 1960), D
Andreas Schlüter (* 1958)
Ann-Helena Schlüter
Herman Schmalenbach (1885–1950), D
Werner Schmalenbach (1920–2010), D/CH
Dagmar Isabell Schmidbauer (* 1962), D
Wolfgang Schmidbauer (* 1941), D
Alfred Schmidt (1931–2012), D
Arno Schmidt (1914–1979), D
Christian Schmidt (1980), D
Helmut Schmidt (1918–2015), D
Helwig Schmidt-Glintzer (* 1948), D
Kathrin Schmidt (* 1958), D
Rudolf Schmidt (1875–1943), D
Wendelin Schmidt-Dengler (1942–2008), AT
Gerhard Schmidtchen (1925–2022), D
Wieland Schmied (1929–2014), AT
Marion Schmitt (* 1959)
Philipp Schmitz (1935–2015)
Johann Gottfried Schnabel (1692–1744/1748)
Siegfried Schnabl (1927–2015), D
Friedrich Schnack (1888–1977)
Harald Schneider (* 1962)
Karla Schneider (* 1938), D
Peter Schneider (* 1940), D
Reinhold Schneider (1903–1958), D
Wolfgang Schneider (1938–2003), D
Robert Wolfgang Schnell (1916–1986), D
Helmut Schnelle (1932–2015), D
Arthur Schnitzler (1862–1931), AT
Wolfdietrich Schnurre (1920–1989), D
Axel Schock (* 1965), D
Wilfried F. Schoeller (1941–2020), D
Christel Schöllhammer (* 1938), D
Peter Schoenen (1952–2014), D
Sigmar Schollak (1930–2012), D
Peter Scholl-Latour (1924–2014), D/FR
Eike Schönfeld (* 1949), D
Dietmar Schönherr (1926–2014)
Johannes Schönherr (1894–1961)
Karl Schönherr (1867–1943)
Katja Schönherr (* 1982)
Renate Schoof (* 1950) D
Adele Schopenhauer (1797–1849)
Arthur Schopenhauer (1788–1860)
Roberto Schopflocher (1923–2016)
Eberhard Schorsch (1935–1991)
Carl E. Schorske (1915–2015), US
Claudia Schoppmann (* 1958), D
Justus Georg Schottelius (1612–1676)
Julie Schrader (1881–1939), D
Daniel Schreiber (* 1977), D
Hermann Schreiber (1920–2014)
Hermann Schreiber (1929–2020)
Jürgen Schreiber (1947–2022), D
Karl-Heinz Schreiber (1949–2014)
Klaus Peter Schreiner (1930–2017), D
Peter Schreiner (* 1953), D
Angelika Schrobsdorff (1927–2016)
Rudolf Alexander Schröder (1878–1962), D
Willy Schrödter (1878–1971)
Raoul Schrott (* 1964), AT
Jürg Schubiger (1936–2014), CH
Bernd Schuh (* 1948), D
Jean-Jacques Schuhl (* 1941), FR
Herbert Schui (1940–2016), D
Budd Schulberg (1914–2009), US
Herbert Schuldt (* 1941)
Horst Schüler-Springorum (1928–2015), D
Sarah Schulman (* 1958), US
Bruno Schulz (1892–1942), PL
Frank Schulz (* 1957), D
Franz Schulz (1897–1971), AT/US
Hagen Schulze (1943–2014), D
Micha Schulze (* 1967), D
Hans-Eugen Schulze (1922–2013), D
Ingo Schulze (* 1962), D
Dirk Schümer (* 1962), D
Romy Schurhammer (1936–2019), D
Maik T. Schurkus (* 1970), D
Wolfram Schütte (* 1939), D
Silke Schütze (* 1961), D
Stephan Schütze (1771–1839), D
James Schuyler (1923–1991), USA
Gustav Schwab (1792–1850), D
Werner Schwab (1958–1994), AT
Brigitte Schwaiger (1949–2010), AT
Marcel Schwander (1929–2010), CH
Delmore Schwartz (1913–1966), US
Lynne Sharon Schwartz (* 1939), US
Alice Schwarzer (* 1942), D
Alfred Otto Schwede (1915–1987), D
Michael Schweer
Albert Schweitzer (1875–1965), D / FR
Rolf Schwendter (1939–2013), AT
Hermann Schweppenhäuser (1928–2015), D
Malin Schwerdtfeger (* 1972), D
Ulrike Schwieren-Höger (* 1951), D
Peter Schwindt (* 1964), D
Monique Schwitter (* 1972), CH / D
Kurt Schwitters (1887–1948), D
Leonardo Sciascia (1921–1989), IT
C. R. Scott (* 1984), D
Gil Scott-Heron (1949–2011), US
Melissa Scott (* 1960), US
Michael Scott (* 1959), IRL
Sir Walter Scott (1771–1832)
Lisa Scottoline (* 1955), US
Joseph Medlicott Scriven (1820–1886)
Roger Scruton (1944–2020), GB
Madeleine de Scudéry (1607–1701)

Se 
Charles Sealsfield (1793–1864)
W. G. Sebald (1944–2001)
David Sedaris (* 1956)
Eve Kosofsky Sedgwick (1950–2009)
Annette Seemann (* 1959)
Peter Seewald (* 1954)
Giorgos Seferis (1900–1971)
Erich Segal (1937–2010)
Tom Segev (* 1945)
Anna Seghers (1900–1983)
Jan Seghers (* 1958)
Georg Seidel (1945–1990)
Heinrich Seidel (1842–1906)
Heinrich Wolfgang Seidel (1876–1945)
Ina Seidel (1885–1974)
Oskar Seidlin (1911–1984)
John Seigenthaler senior (1927–2014)
Lutz Seiler (* 1963), D
Susanne Seitz (* 1964)
Martin Selber (1924–2006)
Erich Selbmann (1926–2006)
Fritz Selbmann (1899–1975)
Dirk Seliger (* 1970)
Rafael Seligmann (* 1947)
Shyam Selvadurai (* 1965)
Friedrich Hermann Semmig (1820–1897)
Jeanne Berta Semmig (1867–1958)
Jaime Semprun (1947–2010)
Jorge Semprún (1923–2011)
Amartya Sen (* 1933)
Maurice Sendak (1928–2012)
Ramón J. Sender (1901–1982)
Nedim Şener (* 1966)
Richard Sennett (* 1943)
Zafer Şenocak (* 1961)
Luis Sepúlveda (1949–2020)
Lucius Annaeus Seneca (55 v. Chr. – 40 n. Chr.)
Seo Jeong-in (* 1936)
Seo Young-eun (* 1943)
Wolf Serno (* 1944)
Walter Serner (1889–1942)
Michel Serres (1930–2019)
Clemens J. Setz (* 1982)
Wolfram Setz (1941–2023)
Bernhard Setzwein (* 1960)
Johann Gottfried Seume (1763–1810)
Beppe Severgnini (* 1956)
Ruth Seydewitz (1905–1989)
Napoleon Seyfarth (1953–2000)
Joachim Seyppel (1919–2012)
Hilal Sezgin (* 1970)

Sg 
Manlio Sgalambro (1924–2014)

Sh 
Elif Shafak (* 1971)
Peter Shaffer (1926–2016)
William Shakespeare (1564–1616)
Meir Shalev (1948–2023)
Zeruya Shalev (* 1959)
Ralph Shallis († 1995)
Sidney Shapiro (1915–2014)
Tom Sharpe (1928–2013)
George Bernard Shaw (1856–1950)
Irwin Shaw (1913–1984)
Patricia Shaw (* 1929)
Robert Sheckley (1928–2005)
Maurice Sheehy (1928–1991)
Mary Wollstonecraft Shelley (1797–1851)
Percy Bysshe Shelley (1792–1822)
Lucius Shepard (1947–2014)
Richard Brinsley Sheridan (1751–1816)
Randy Shilts (1951–1994)
Shin Kyong-nim (* 1936)
Vladimir Shlapentokh (1926–2015)

Si 
Jules Siber (1871–1943)
Gertrud Siche-Tarnowski
Barbara Sichtermann (* 1943)
Enzo Siciliano (1934–2006)
Wolfram Siebeck (1928–2016)
Wolf Jobst Siedler (1926–2013)
Martin Siems (1948–2020)
Hans Siemsen (1891–1969)
Henryk Sienkiewicz (1846–1916)
Christian Sigrist (1935–2015)
Volkmar Sigusch (1940–2023)
Arthur Silbergleit (1881–1943)
Alan Sillitoe (1928–2010)
Ignazio Silone (1900–1978)
Charles Silverstein (1935–2023)
Clifford D. Simak (1904–1988)
Georges Simenon (1903–1989)
Charles Simic (1938–2023)
Georg Simmel (1858–1918)
Johannes Mario Simmel (1924–2009)
Claude Simon (1913–2005)
Erik Simon (* 1950)
Simonides von Amorgos (7. Jahrhundert v. Chr.)
Simonides von Keos (557 oder 556 – 468 oder 467 v. Chr.)
Konstantin Simonow (1915–1979)
N. F. Simpson (1919–2011)
Hüseyin Şimşek (* 1962)
Sin Kyong-suk (* 1963)
Upton Sinclair (1878–1968)
Isaac B. Singer (1904–1991)
Khushwant Singh (1915–2014)
Saut Situmorang (* 1966)
Sitor Situmorang (1924–2014)
Edith Sitwell (1887–1964)

Sj–So 
Arne Sjöberg Paul Brinkmann (1934–1997)
Maj Sjöwall (1935–2020)
Maya Skiba (* 1989)
Hamid Skif (1951–2011)
Scipio Slataper (1888–1915)
Henry Slesar (1927–2002)
Ondreij Sliacki (1849–1921)
Joshua Slocum (1844–1909)
Joan Slonczewski (* 1956)
Peter Sloterdijk (* 1947)
Clark Ashton Smith (1893–1961)
Cordwainer Smith Paul Linebarger (1913–1966)
Emma Smith (1923–2018)
Lillian Smith (1897–1966)
Martin Cruz Smith (* 1942)
Stevie Smith (1902–1971)
Wilbur Smith (1933–2021)
Ján Smrek (1898–1982)
Timothy Snyder (* 1969)
Dava Sobel (* 1947), US
Jehoschua Sobol (* 1939)
Ernst Solèr (1960–2008)
Philippe Sollers (1936–2023)
Franco Solo (Verlagspseudonym, verschiedene Autoren)
Alexander Solschenizyn (1918–2008)
Nicolaus Sombart (1923–2008)
Werner Sombart (1863–1941)
Volker Sommer (* 1954)
Hugo Sonnenschein (1889–1953)
Marco Sonnleitner (* 1965)
Susan Sontag (1933–2004)
Michael Sontheimer (* 1955)
Sophokles (497/96–≈406 v.a.Z.)
Osvaldo Soriano (1943–1997)
Flavio Soriga (* 1975)
Wladimir Sorokin (* 1955)
Dido Sotiriou (1909–2004)
Philippe Soupault (1897–1990)
Ivan Southall (1921–2008)
Johannes K. Soyener (1945–2018)
Jura Soyfer (1912–1939)
Wole Soyinka (* 1934)

Sp 
Tom Spanbauer (* 1946), US
Muriel Spark (1918–2006), GB
Nicholas Sparks (* 1965), US
Bernd Späth (* 1950), D
Gerold Späth (* 1939), CH
Stephen Spender (1909–1995), GB
Tilman Spengler (* 1947), D
Manès Sperber (1905–1984), AT
Martin Sperr (1944–2002), D
Monika Sperr (1941–1984), D
Dieter Spethmann (1926–2016), D
Art Spiegelman (* 1948), US
Erik Spiekermann (* 1947), D
Arndt Spieth (* 1962), D
Erica Spindler (* 1957), US
Jerry Spinelli (* 1941), US
Burkhard Spinnen (* 1956), D
Carl Spitteler (1845–1924), CH
Robert L. Spitzer (1932–2015), US
Heinrich Spoerl (1887–1955), D
C.M. Spoerri (* 1983), CH
Donald Spoto (1941–2023), US/DK
Hans-Hermann Sprado (1956–2014), D
Johanna Spyri (1827–1901), CH

St

Sta – Ste 
 Reiner Stach (* 1951), D
 Emerich von Stadion (1838–1901), AT
 Anne Louise Germaine de Staël (1766–1817)
 Helmut Stalder (* 1966), CH
 George Stambolian (1938–1991), US
 Peter Stamm (* 1963), CH
 Regula Stämpfli (* 1962), CH
 Henry Morton Stanley (1841–1904), GB
 Pietro Stanzano (1928–1968), IT
 Andrzej Stasiuk (* 1960), PL
 Joseph Staten, US
 Edward St Aubyn (* 1960), GB
 Toralf Staud (* 1972), D
 Robert Stauffer (* 1936), D
 Michael Stavarič (* 1972), AT
 John Stave (1929–1993), D
 Jerzy Stefan Stawiński (1921–2010), PL
 Bernhard Stecher (* 1961), A
 Danielle Steel (* 1947), US
 Verena Stefan (1947–2017), CH
 Jón Kalman Stefánsson (* 1963)
 Hansjakob Stehle (1927–2015), D
 Robert Steigerwald (1925–2016), D
 Gertrude Stein (1874–1946), US
 Peter Steinacker (1943–2015), D
 Thomas von Steinaecker (* 1977), D
 Peter Steinbach (Drehbuchautor) (1938–2019), D
 Peter Steinbach (Historiker) (* 1948), D
 John Steinbeck (1902–1968), US
 Guido Steinberg (* 1968), D
 Karl Steinbuch (1917–2005)
 George Steiner (1929–2020), US
 Jens Steiner (* 1975), CH
 Jörg Steiner (1930–2013), CH
 Andreas Steinhöfel (* 1962), D
 Klaus Steiniger (1932–2016), D
 Ronen Steinke (* 1983), D
 Marlene Stenten (1935–2019), D
 Neal Stephenson (* 1959), US
 Carola Stern (1925–2006), D
 Fritz Stern (1926–2016), US
 Horst Stern (1922–2019), D
 Carl Sternheim (1878–1942)
 Norbert Sternmut (* 1958)
 Andreas Sternweiler (* 1957), D
 Julius Stettenheim (1831–1916)
 Johann Kaspar Steube (1747–1795)
 Karl Steuerwald (1905–1989), D
 Wallace Stevens (1879–1955), US
 Robert Louis Stevenson (1850–1894)
 Samuel M. Steward (1909–1993), US
 Fred Mustard Stewart
 Mary Stewart (1916–2014), GB

Sti – Sty 
Vicki Stiefel, US
Caspar von Stieler (1632–1707)
Helm Stierlin (1926–2021), D
Adalbert Stifter (1805–1868), D
Klaus Stiller (* 1941), D
Michael Stiller (1945–2016), D
Julius Stinde (1841–1905), D
Conradine Stinde (1856–1925), D
Helene Stöcker (1869–1943), D
Juliana von Stockhausen (1899–1998), D
Charles Warren Stoddard (1843–1909), GB
Dejan Stojanović (* 1959), US, SR
Ceija Stojka (1933–2013), AT
Bram Stoker (1847–1912), GB
Clifford Stoll (* 1950), US
Michael Stolleis (1941–2021), D
Robert Stoller (1925–1991), US
Aryeh Lev Stollman (* 1954), US
Manfred Stolpe (1936–2019), D
Irving Stone (1903–1989), US
Hans Joachim Störig (1915–2012), D
Theodor Storm (1817–1888), D
Rex Stout (1886–1975), US
Horst Stowasser (1951–2009)
Lytton Strachey (1880–1932), GB
August Stramm (1874–1915), D
Giovanni Francisco Straparola (~1480–~1558)
Botho Strauß (* 1944), D
Emil Strauß (1866–1960), D
Leo Strauss (1899–1973)
Werner Streletz (* 1949), D
Carlo Strenger (1958–2019), CH/ISR
Jan Stressenreuter (1961–2018), D
Johan August Strindberg (1849–1912)
Erwin Strittmatter (1912–1994), D
Eva Strittmatter (1930–2011), D
Tina Stroheker (* 1948), D
Anna Stroka (1923–2020), PL
Gisbert Strotdrees (* 1960), D
Arkadi Strugazki, RUS
Boris Strugazki, RUS
Ulf G. Stuberger (1949–2015), D
Heinz Stübig (1939–2021), D
Benjamin von Stuckrad-Barre (* 1975), D
Giani Stuparich (1891–1961), IT
Howard O. Sturgis (1855–1920), GB
Jakob Stutz (1801–1871), SCHW
William Styron (1925–2006), US

Su–Sz 
Andreas Suchanek (* 1982)
Hermann Sudermann (1857–1928)
Eugène Sue (1804–1859)
Hannes Sulzenbacher (* 1968)
Alain Claude Sulzer (* 1953)
Ingo Sundmacher (* 1965)
Sung Suk-je (* 1960)
Wolfgang Suppan (1933–2015)
Peter Surava (1912–1995)
Manil Suri (* 1959)
Arno Surminski (* 1934)
Ida Sury (1911–2004), CH
Patrick Süskind (* 1949)
Ron Suresha (* 1958)
Paul Sussman (1968–2012)
Rosemary Sutcliff (1920–1992)
Martin Suter (* 1948)
Bertha von Suttner (1843–1914)
Italo Svevo (1861–1928)
Leonie Swann (* 1975)
Emanuel Swedenborg (1688–1772)
Matthew Sweeney (1952–2018)
Jonathan Swift (1667–1745)
Algernon Charles Swinburne (1837–1909)
John Addington Symonds (1840–1893)
Arthur William Symons (1865–1945)
Julian Symons (1912–1994)
John Millington Synge (1871–1909)
Michael Szameit (1950–2014)
Thomas Szasz (1920–2012)
Antal Szerb (1901–1945)

S

#!/usr/bin/env node
'use strict';

var _ = require('../lodash'),
    fs = require('fs'),
    path = require('path');

var args = (args = process.argv)
  .slice((args[0] === process.execPath || args[0] === 'node') ? 2 : 0);

var filePath = path.resolve(args[1]),
    reLine = /.*/gm;

var pattern = (function() {
  var result = args[0],
      delimiter = result.charAt(0),
      lastIndex = result.lastIndexOf(delimiter);

  return RegExp(result.slice(1, lastIndex), result.slice(lastIndex + 1));
}());

/*----------------------------------------------------------------------------*/

fs.writeFileSync(filePath, fs.readFileSync(filePath, 'utf8').replace(pattern, function(match) {
  var snippet = _.slice(arguments, -3, -2)[0];
  return match.replace(snippet, snippet.replace(reLine, ''));
}));

import pytest

import click.types

# Common (obj, expect) pairs used to construct multiple tests.
STRING_PARAM_TYPE = (click.STRING, {"param_type": "String", "name": "text"})
INT_PARAM_TYPE = (click.INT, {"param_type": "Int", "name": "integer"})
BOOL_PARAM_TYPE = (click.BOOL, {"param_type": "Bool", "name": "boolean"})
HELP_OPTION = (
    None,
    {
        "name": "_click_default_help",
        "param_type_name": "option",
        "opts": ["--help"],
        "secondary_opts": [],
        "type": BOOL_PARAM_TYPE[1],
        "required": False,
        "nargs": 1,
        "multiple": False,
        "default": False,
        "envvar": None,
        "help": "Show this message and exit.",
        "prompt": None,
        "is_flag": True,
        "flag_value": True,
        "count": False,
        "hidden": False,
    },
)
NAME_ARGUMENT = (
    click.Argument(["name"]),
    {
        "name": "name",
        "param_type_name": "argument",
        "opts": ["name"],
        "secondary_opts": [],
        "type": STRING_PARAM_TYPE[1],
        "required": True,
        "nargs": 1,
        "multiple": False,
        "default": None,
        "envvar": None,
        "help": None,
    },
)
NUMBER_OPTION = (
    click.Option(["-c", "--count", "number"], default=1),
    {
        "name": "number",
        "param_type_name": "option",
        "opts": ["-c", "--count"],
        "secondary_opts": [],
        "type": INT_PARAM_TYPE[1],
        "required": False,
        "nargs": 1,
        "multiple": False,
        "default": 1,
        "envvar": None,
        "help": None,
        "prompt": None,
        "is_flag": False,
        "flag_value": None,
        "count": False,
        "hidden": False,
    },
)
HELLO_COMMAND = (
    click.Command("hello", params=[NUMBER_OPTION[0]]),
    {
        "name": "hello",
        "params": [NUMBER_OPTION[1], HELP_OPTION[1]],
        "help": None,
        "epilog": None,
        "short_help": None,
        "hidden": False,
        "deprecated": False,
    },
)
HELLO_GROUP = (
    click.Group("cli", [HELLO_COMMAND[0]]),
    {
        "name": "cli",
        "params": [HELP_OPTION[1]],
        "help": None,
        "epilog": None,
        "short_help": None,
        "hidden": False,
        "deprecated": False,
        "commands": {"hello": HELLO_COMMAND[1]},
        "chain": False,
    },
)


@pytest.mark.parametrize(
    ("obj", "expect"),
    [
        pytest.param(
            click.types.FuncParamType(range),
            {"param_type": "Func", "name": "range", "func": range},
            id="Func ParamType",
        ),
        pytest.param(
            click.UNPROCESSED,
            {"param_type": "Unprocessed", "name": "text"},
            id="UNPROCESSED ParamType",
        ),
        pytest.param(*STRING_PARAM_TYPE, id="STRING ParamType"),
        pytest.param(
            click.Choice(("a", "b")),
            {
                "param_type": "Choice",
                "name": "choice",
                "choices": ("a", "b"),
                "case_sensitive": True,
            },
            id="Choice ParamType",
        ),
        pytest.param(
            click.DateTime(["%Y-%m-%d"]),
            {"param_type": "DateTime", "name": "datetime", "formats": ["%Y-%m-%d"]},
            id="DateTime ParamType",
        ),
        pytest.param(*INT_PARAM_TYPE, id="INT ParamType"),
        pytest.param(
            click.IntRange(0, 10, clamp=True),
            {
                "param_type": "IntRange",
                "name": "integer range",
                "min": 0,
                "max": 10,
                "min_open": False,
                "max_open": False,
                "clamp": True,
            },
            id="IntRange ParamType",
        ),
        pytest.param(
            click.FLOAT, {"param_type": "Float", "name": "float"}, id="FLOAT ParamType"
        ),
        pytest.param(
            click.FloatRange(-0.5, 0.5),
            {
                "param_type": "FloatRange",
                "name": "float range",
                "min": -0.5,
                "max": 0.5,
                "min_open": False,
                "max_open": False,
                "clamp": False,
            },
            id="FloatRange ParamType",
        ),
        pytest.param(*BOOL_PARAM_TYPE, id="Bool ParamType"),
        pytest.param(
            click.UUID, {"param_type": "UUID", "name": "uuid"}, id="UUID ParamType"
        ),
        pytest.param(
            click.File(),
            {"param_type": "File", "name": "filename", "mode": "r", "encoding": None},
            id="File ParamType",
        ),
        pytest.param(
            click.Path(),
            {
                "param_type": "Path",
                "name": "path",
                "exists": False,
                "file_okay": True,
                "dir_okay": True,
                "writable": False,
                "readable": True,
                "allow_dash": False,
            },
            id="Path ParamType",
        ),
        pytest.param(
            click.Tuple((click.STRING, click.INT)),
            {
                "param_type": "Tuple",
                "name": "<text integer>",
                "types": [STRING_PARAM_TYPE[1], INT_PARAM_TYPE[1]],
            },
            id="Tuple ParamType",
        ),
        pytest.param(*NUMBER_OPTION, id="Option"),
        pytest.param(
            click.Option(["--cache/--no-cache", "-c/-u"]),
            {
                "name": "cache",
                "param_type_name": "option",
                "opts": ["--cache", "-c"],
                "secondary_opts": ["--no-cache", "-u"],
                "type": BOOL_PARAM_TYPE[1],
                "required": False,
                "nargs": 1,
                "multiple": False,
                "default": False,
                "envvar": None,
                "help": None,
                "prompt": None,
                "is_flag": True,
                "flag_value": True,
                "count": False,
                "hidden": False,
            },
            id="Flag Option",
        ),
        pytest.param(*NAME_ARGUMENT, id="Argument"),
    ],
)
def test_parameter(obj, expect):
    out = obj.to_info_dict()
    assert out == expect


@pytest.mark.parametrize(
    ("obj", "expect"),
    [
        pytest.param(*HELLO_COMMAND, id="Command"),
        pytest.param(*HELLO_GROUP, id="Group"),
        pytest.param(
            click.Group(
                "base",
                [click.Command("test", params=[NAME_ARGUMENT[0]]), HELLO_GROUP[0]],
            ),
            {
                "name": "base",
                "params": [HELP_OPTION[1]],
                "help": None,
                "epilog": None,
                "short_help": None,
                "hidden": False,
                "deprecated": False,
                "commands": {
                    "cli": HELLO_GROUP[1],
                    "test": {
                        "name": "test",
                        "params": [NAME_ARGUMENT[1], HELP_OPTION[1]],
                        "help": None,
                        "epilog": None,
                        "short_help": None,
                        "hidden": False,
                        "deprecated": False,
                    },
                },
                "chain": False,
            },
            id="Nested Group",
        ),
    ],
)
def test_command(obj, expect):
    ctx = click.Context(obj)
    out = obj.to_info_dict(ctx)
    assert out == expect


def test_context():
    ctx = click.Context(HELLO_COMMAND[0])
    out = ctx.to_info_dict()
    assert out == {
        "command": HELLO_COMMAND[1],
        "info_name": None,
        "allow_extra_args": False,
        "allow_interspersed_args": True,
        "ignore_unknown_options": False,
        "auto_envvar_prefix": None,
    }


def test_paramtype_no_name():
    class TestType(click.ParamType):
        pass

    assert TestType().to_info_dict()["name"] == "TestType"


@pytest.mark.parametrize(
    ("help_in", "help_out"),
    [
        pytest.param(None, None, id="None"),
        pytest.param("", "", id="empty"),
        pytest.param("single line", "single line", id="single-line"),
        pytest.param(
            "\n    first line\n    second line\n    ",
            "first line\nsecond line",
            id="multi-line",
        ),
    ],
)
def test_argument_to_info_dict_help(help_in, help_out):
    arg = click.Argument(["name"], help=help_in)
    assert arg.to_info_dict()["help"] == help_out


def test_argument_to_info_dict_nargs():
    arg = click.Argument(["files"], nargs=-1, help="files to process")
    info = arg.to_info_dict()
    assert info["nargs"] == -1
    assert info["help"] == "files to process"


def test_command_to_info_dict_multiple_arguments():
    @click.command()
    @click.argument("src", help="source path")
    @click.argument("dst", help="destination path")
    def cli(src, dst):
        pass

    ctx = click.Context(cli)
    params = cli.to_info_dict(ctx)["params"]
    args = [p for p in params if p["param_type_name"] == "argument"]
    assert [p["name"] for p in args] == ["src", "dst"]
    assert [p["help"] for p in args] == ["source path", "destination path"]

//! Structured values.
//!
//! This module defines the [`Value`] type and supporting APIs for
//! capturing and serializing them.

use std::fmt;

pub use crate::kv::Error;

/// A type that can be converted into a [`Value`](struct.Value.html).
pub trait ToValue {
    /// Perform the conversion.
    fn to_value(&self) -> Value<'_>;
}

impl<T> ToValue for &T
where
    T: ToValue + ?Sized,
{
    fn to_value(&self) -> Value<'_> {
        (**self).to_value()
    }
}

impl<'v> ToValue for Value<'v> {
    fn to_value(&self) -> Value<'_> {
        Value {
            inner: self.inner.clone(),
        }
    }
}

/// A value in a key-value.
///
/// Values are an anonymous bag containing some structured datum.
///
/// # Capturing values
///
/// There are a few ways to capture a value:
///
/// - Using the `Value::from_*` methods.
/// - Using the `ToValue` trait.
/// - Using the standard `From` trait.
///
/// ## Using the `Value::from_*` methods
///
/// `Value` offers a few constructor methods that capture values of different kinds.
///
/// ```
/// use log::kv::Value;
///
/// let value = Value::from_debug(&42i32);
///
/// assert_eq!(None, value.to_i64());
/// ```
///
/// ## Using the `ToValue` trait
///
/// The `ToValue` trait can be used to capture values generically.
/// It's the bound used by `Source`.
///
/// ```
/// # use log::kv::ToValue;
/// let value = 42i32.to_value();
///
/// assert_eq!(Some(42), value.to_i64());
/// ```
///
/// ## Using the standard `From` trait
///
/// Standard types that implement `ToValue` also implement `From`.
///
/// ```
/// use log::kv::Value;
///
/// let value = Value::from(42i32);
///
/// assert_eq!(Some(42), value.to_i64());
/// ```
///
/// # Data model
///
/// Values can hold one of a number of types:
///
/// - **Null:** The absence of any other meaningful value. Note that
///   `Some(Value::null())` is not the same as `None`. The former is
///   `null` while the latter is `undefined`. This is important to be
///   able to tell the difference between a key-value that was logged,
///   but its value was empty (`Some(Value::null())`) and a key-value
///   that was never logged at all (`None`).
/// - **Strings:** `str`, `char`.
/// - **Booleans:** `bool`.
/// - **Integers:** `u8`-`u128`, `i8`-`i128`, `NonZero*`.
/// - **Floating point numbers:** `f32`-`f64`.
/// - **Errors:** `dyn (Error + 'static)`.
/// - **`serde`:** Any type in `serde`'s data model.
/// - **`sval`:** Any type in `sval`'s data model.
///
/// # Serialization
///
/// Values provide a number of ways to be serialized.
///
/// For basic types the [`Value::visit`] method can be used to extract the
/// underlying typed value. However, this is limited in the amount of types
/// supported (see the [`VisitValue`] trait methods).
///
/// For more complex types one of the following traits can be used:
///  * `sval::Value`, requires the `kv_sval` feature.
///  * `serde::Serialize`, requires the `kv_serde` feature.
///
/// You don't need a visitor to serialize values through `serde` or `sval`.
///
/// A value can always be serialized using any supported framework, regardless
/// of how it was captured. If, for example, a value was captured using its
/// `Display` implementation, it will serialize through `serde` as a string. If it was
/// captured as a struct using `serde`, it will also serialize as a struct
/// through `sval`, or can be formatted using a `Debug`-compatible representation.
#[derive(Clone)]
pub struct Value<'v> {
    inner: inner::Inner<'v>,
}

impl<'v> Value<'v> {
    /// Get a value from a type implementing `ToValue`.
    pub fn from_any<T>(value: &'v T) -> Self
    where
        T: ToValue,
    {
        value.to_value()
    }

    /// Get a value from a type implementing `std::fmt::Debug`.
    pub fn from_debug<T>(value: &'v T) -> Self
    where
        T: fmt::Debug,
    {
        Value {
            inner: inner::Inner::from_debug(value),
        }
    }

    /// Get a value from a type implementing `std::fmt::Display`.
    pub fn from_display<T>(value: &'v T) -> Self
    where
        T: fmt::Display,
    {
        Value {
            inner: inner::Inner::from_display(value),
        }
    }

    /// Get a value from a type implementing `serde::Serialize`.
    #[cfg(feature = "kv_serde")]
    pub fn from_serde<T>(value: &'v T) -> Self
    where
        T: serde_core::Serialize,
    {
        Value {
            inner: inner::Inner::from_serde1(value),
        }
    }

    /// Get a value from a type implementing `sval::Value`.
    #[cfg(feature = "kv_sval")]
    pub fn from_sval<T>(value: &'v T) -> Self
    where
        T: sval::Value,
    {
        Value {
            inner: inner::Inner::from_sval2(value),
        }
    }

    /// Get a value from a dynamic `std::fmt::Debug`.
    pub fn from_dyn_debug(value: &'v dyn fmt::Debug) -> Self {
        Value {
            inner: inner::Inner::from_dyn_debug(value),
        }
    }

    /// Get a value from a dynamic `std::fmt::Display`.
    pub fn from_dyn_display(value: &'v dyn fmt::Display) -> Self {
        Value {
            inner: inner::Inner::from_dyn_display(value),
        }
    }

    /// Get a value from a dynamic error.
    #[cfg(feature = "kv_std")]
    pub fn from_dyn_error(err: &'v (dyn std::error::Error + 'static)) -> Self {
        Value {
            inner: inner::Inner::from_dyn_error(err),
        }
    }

    /// Get a `null` value.
    pub fn null() -> Self {
        Value {
            inner: inner::Inner::empty(),
        }
    }

    /// Get a value from an internal primitive.
    fn from_inner<T>(value: T) -> Self
    where
        T: Into<inner::Inner<'v>>,
    {
        Value {
            inner: value.into(),
        }
    }

    /// Inspect this value using a simple visitor.
    ///
    /// When the `kv_serde` or `kv_sval` features are enabled, you can also
    /// serialize a value using its `Serialize` or `Value` implementation.
    pub fn visit(&self, visitor: impl VisitValue<'v>) -> Result<(), Error> {
        inner::visit(&self.inner, visitor)
    }
}

impl<'v> fmt::Debug for Value<'v> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Debug::fmt(&self.inner, f)
    }
}

impl<'v> fmt::Display for Value<'v> {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        fmt::Display::fmt(&self.inner, f)
    }
}

#[cfg(feature = "kv_serde")]
impl<'v> serde_core::Serialize for Value<'v> {
    fn serialize<S>(&self, s: S) -> Result<S::Ok, S::Error>
    where
        S: serde_core::Serializer,
    {
        self.inner.serialize(s)
    }
}

#[cfg(feature = "kv_sval")]
impl<'v> sval::Value for Value<'v> {
    fn stream<'sval, S: sval::Stream<'sval> + ?Sized>(&'sval self, stream: &mut S) -> sval::Result {
        sval::Value::stream(&self.inner, stream)
    }
}

#[cfg(feature = "kv_sval")]
impl<'v> sval_ref::ValueRef<'v> for Value<'v> {
    fn stream_ref<S: sval::Stream<'v> + ?Sized>(&self, stream: &mut S) -> sval::Result {
        sval_ref::ValueRef::stream_ref(&self.inner, stream)
    }
}

impl ToValue for str {
    fn to_value(&self) -> Value<'_> {
        Value::from(self)
    }
}

impl<'v> From<&'v str> for Value<'v> {
    fn from(value: &'v str) -> Self {
        Value::from_inner(value)
    }
}

impl ToValue for () {
    fn to_value(&self) -> Value<'_> {
        Value::from_inner(())
    }
}

impl<T> ToValue for Option<T>
where
    T: ToValue,
{
    fn to_value(&self) -> Value<'_> {
        match *self {
            Some(ref value) => value.to_value(),
            None => Value::from_inner(()),
        }
    }
}

macro_rules! impl_to_value_primitive {
    ($($into_ty:ty,)*) => {
        $(
            impl ToValue for $into_ty {
                fn to_value(&self) -> Value<'_> {
                    Value::from(*self)
                }
            }

            impl<'v> From<$into_ty> for Value<'v> {
                fn from(value: $into_ty) -> Self {
                    Value::from_inner(value)
                }
            }

            impl<'v> From<&'v $into_ty> for Value<'v> {
                fn from(value: &'v $into_ty) -> Self {
                    Value::from_inner(*value)
                }
            }
        )*
    };
}

macro_rules! impl_to_value_nonzero_primitive {
    ($($into_ty:ident,)*) => {
        $(
            impl ToValue for std::num::$into_ty {
                fn to_value(&self) -> Value<'_> {
                    Value::from(self.get())
                }
            }

            impl<'v> From<std::num::$into_ty> for Value<'v> {
                fn from(value: std::num::$into_ty) -> Self {
                    Value::from(value.get())
                }
            }

            impl<'v> From<&'v std::num::$into_ty> for Value<'v> {
                fn from(value: &'v std::num::$into_ty) -> Self {
                    Value::from(value.get())
                }
            }
        )*
    };
}

macro_rules! impl_value_to_primitive {
    ($(#[doc = $doc:tt] $into_name:ident -> $into_ty:ty,)*) => {
        impl<'v> Value<'v> {
            $(
                #[doc = $doc]
                pub fn $into_name(&self) -> Option<$into_ty> {
                    self.inner.$into_name()
                }
            )*
        }
    }
}

impl_to_value_primitive![
    usize, u8, u16, u32, u64, u128, isize, i8, i16, i32, i64, i128, f32, f64, char, bool,
];

#[rustfmt::skip]
impl_to_value_nonzero_primitive![
    NonZeroUsize, NonZeroU8, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU128,
    NonZeroIsize, NonZeroI8, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI128,
];

impl_value_to_primitive![
    #[doc = "Try convert this value into a `u64`."]
    to_u64 -> u64,
    #[doc = "Try convert this value into a `i64`."]
    to_i64 -> i64,
    #[doc = "Try convert this value into a `u128`."]
    to_u128 -> u128,
    #[doc = "Try convert this value into a `i128`."]
    to_i128 -> i128,
    #[doc = "Try convert this value into a `f64`."]
    to_f64 -> f64,
    #[doc = "Try convert this value into a `char`."]
    to_char -> char,
    #[doc = "Try convert this value into a `bool`."]
    to_bool -> bool,
];

#[cfg(feature = "std")]
macro_rules! impl_to_value_from_display {
    ($($into_ty:ty,)*) => {
        $(
            impl ToValue for $into_ty {
                fn to_value(&self) -> Value<'_> {
                    Value::from_display(self)
                }
            }

            impl<'v> From<&'v $into_ty> for Value<'v> {
                fn from(value: &'v $into_ty) -> Self {
                    Value::from_display(value)
                }
            }
        )*
    };
}

#[cfg(feature = "std")]
impl_to_value_from_display![
    std::net::IpAddr,
    std::net::Ipv4Addr,
    std::net::Ipv6Addr,
    std::net::SocketAddr,
    std::net::SocketAddrV4,
    std::net::SocketAddrV6,
];

impl<'v> Value<'v> {
    /// Try to convert this value into an error.
    #[cfg(feature = "kv_std")]
    pub fn to_borrowed_error(&self) -> Option<&(dyn std::error::Error + 'static)> {
        self.inner.to_borrowed_error()
    }

    /// Try to convert this value into a borrowed string.
    pub fn to_borrowed_str(&self) -> Option<&'v str> {
        self.inner.to_borrowed_str()
    }
}

#[cfg(feature = "std")]
mod std_support {
    use std::borrow::Cow;
    use std::rc::Rc;
    use std::sync::Arc;

    use super::*;

    impl<T> ToValue for Box<T>
    where
        T: ToValue + ?Sized,
    {
        fn to_value(&self) -> Value<'_> {
            (**self).to_value()
        }
    }

    impl<T> ToValue for Arc<T>
    where
        T: ToValue + ?Sized,
    {
        fn to_value(&self) -> Value<'_> {
            (**self).to_value()
        }
    }

    impl<T> ToValue for Rc<T>
    where
        T: ToValue + ?Sized,
    {
        fn to_value(&self) -> Value<'_> {
            (**self).to_value()
        }
    }

    impl ToValue for String {
        fn to_value(&self) -> Value<'_> {
            Value::from(&**self)
        }
    }

    impl<'v> ToValue for Cow<'v, str> {
        fn to_value(&self) -> Value<'_> {
            Value::from(&**self)
        }
    }

    #[cfg(feature = "kv_std")]
    impl<'v> Value<'v> {
        /// Try convert this value into a string.
        pub fn to_cow_str(&self) -> Option<Cow<'v, str>> {
            self.inner.to_str()
        }
    }

    impl<'v> From<&'v String> for Value<'v> {
        fn from(v: &'v String) -> Self {
            Value::from(&**v)
        }
    }
}

/// A visitor for a [`Value`].
///
/// Also see [`Value`'s documentation on serialization]. Value visitors are a simple alternative
/// to a more fully-featured serialization framework like `serde` or `sval`. A value visitor
/// can differentiate primitive types through methods like [`VisitValue::visit_bool`] and
/// [`VisitValue::visit_str`], but more complex types like maps and sequences
/// will fallthrough to [`VisitValue::visit_any`].
///
/// If you're trying to serialize a value to a format like JSON, you can use either `serde`
/// or `sval` directly with the value. You don't need a visitor.
///
/// [`Value`'s documentation on serialization]: Value#serialization
pub trait VisitValue<'v> {
    /// Visit a `Value`.
    ///
    /// This is the only required method on `VisitValue` and acts as a fallback for any
    /// more specific methods that aren't overridden.
    /// The `Value` may be formatted using its `fmt::Debug` or `fmt::Display` implementation,
    /// or serialized using its `sval::Value` or `serde::Serialize` implementation.
    fn visit_any(&mut self, value: Value) -> Result<(), Error>;

    /// Visit an empty value.
    fn visit_null(&mut self) -> Result<(), Error> {
        self.visit_any(Value::null())
    }

    /// Visit an unsigned integer.
    fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
        self.visit_any(value.into())
    }

    /// Visit a signed integer.
    fn visit_i64(&mut self, value: i64) -> Result<(), Error> {
        self.visit_any(value.into())
    }

    /// Visit a big unsigned integer.
    fn visit_u128(&mut self, value: u128) -> Result<(), Error> {
        self.visit_any((value).into())
    }

    /// Visit a big signed integer.
    fn visit_i128(&mut self, value: i128) -> Result<(), Error> {
        self.visit_any((value).into())
    }

    /// Visit a floating point.
    fn visit_f64(&mut self, value: f64) -> Result<(), Error> {
        self.visit_any(value.into())
    }

    /// Visit a boolean.
    fn visit_bool(&mut self, value: bool) -> Result<(), Error> {
        self.visit_any(value.into())
    }

    /// Visit a string.
    fn visit_str(&mut self, value: &str) -> Result<(), Error> {
        self.visit_any(value.into())
    }

    /// Visit a string.
    fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
        self.visit_str(value)
    }

    /// Visit a Unicode character.
    fn visit_char(&mut self, value: char) -> Result<(), Error> {
        let mut b = [0; 4];
        self.visit_str(&*value.encode_utf8(&mut b))
    }

    /// Visit an error.
    #[cfg(feature = "kv_std")]
    fn visit_error(&mut self, err: &(dyn std::error::Error + 'static)) -> Result<(), Error> {
        self.visit_any(Value::from_dyn_error(err))
    }

    /// Visit an error.
    #[cfg(feature = "kv_std")]
    fn visit_borrowed_error(
        &mut self,
        err: &'v (dyn std::error::Error + 'static),
    ) -> Result<(), Error> {
        self.visit_any(Value::from_dyn_error(err))
    }
}

#[allow(clippy::needless_lifetimes)] // Not needless.
impl<'a, 'v, T: ?Sized> VisitValue<'v> for &'a mut T
where
    T: VisitValue<'v>,
{
    fn visit_any(&mut self, value: Value) -> Result<(), Error> {
        (**self).visit_any(value)
    }

    fn visit_null(&mut self) -> Result<(), Error> {
        (**self).visit_null()
    }

    fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
        (**self).visit_u64(value)
    }

    fn visit_i64(&mut self, value: i64) -> Result<(), Error> {
        (**self).visit_i64(value)
    }

    fn visit_u128(&mut self, value: u128) -> Result<(), Error> {
        (**self).visit_u128(value)
    }

    fn visit_i128(&mut self, value: i128) -> Result<(), Error> {
        (**self).visit_i128(value)
    }

    fn visit_f64(&mut self, value: f64) -> Result<(), Error> {
        (**self).visit_f64(value)
    }

    fn visit_bool(&mut self, value: bool) -> Result<(), Error> {
        (**self).visit_bool(value)
    }

    fn visit_str(&mut self, value: &str) -> Result<(), Error> {
        (**self).visit_str(value)
    }

    fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
        (**self).visit_borrowed_str(value)
    }

    fn visit_char(&mut self, value: char) -> Result<(), Error> {
        (**self).visit_char(value)
    }

    #[cfg(feature = "kv_std")]
    fn visit_error(&mut self, err: &(dyn std::error::Error + 'static)) -> Result<(), Error> {
        (**self).visit_error(err)
    }

    #[cfg(feature = "kv_std")]
    fn visit_borrowed_error(
        &mut self,
        err: &'v (dyn std::error::Error + 'static),
    ) -> Result<(), Error> {
        (**self).visit_borrowed_error(err)
    }
}

#[cfg(feature = "value-bag")]
pub(in crate::kv) mod inner {
    /**
    An implementation of `Value` based on a library called `value_bag`.

    `value_bag` was written specifically for use in `log`'s value, but was split out when it outgrew
    the codebase here. It's a general-purpose type-erasure library that handles mapping between
    more fully-featured serialization frameworks.
    */
    use super::*;

    pub use value_bag::ValueBag as Inner;

    pub use value_bag::Error;

    #[cfg(test)]
    pub use value_bag::test::TestToken as Token;

    pub fn visit<'v>(
        inner: &Inner<'v>,
        visitor: impl VisitValue<'v>,
    ) -> Result<(), crate::kv::Error> {
        struct InnerVisitValue<V>(V);

        impl<'v, V> value_bag::visit::Visit<'v> for InnerVisitValue<V>
        where
            V: VisitValue<'v>,
        {
            fn visit_any(&mut self, value: value_bag::ValueBag) -> Result<(), Error> {
                self.0
                    .visit_any(Value { inner: value })
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_empty(&mut self) -> Result<(), Error> {
                self.0.visit_null().map_err(crate::kv::Error::into_value)
            }

            fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
                self.0
                    .visit_u64(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_i64(&mut self, value: i64) -> Result<(), Error> {
                self.0
                    .visit_i64(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_u128(&mut self, value: u128) -> Result<(), Error> {
                self.0
                    .visit_u128(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_i128(&mut self, value: i128) -> Result<(), Error> {
                self.0
                    .visit_i128(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_f64(&mut self, value: f64) -> Result<(), Error> {
                self.0
                    .visit_f64(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_bool(&mut self, value: bool) -> Result<(), Error> {
                self.0
                    .visit_bool(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_str(&mut self, value: &str) -> Result<(), Error> {
                self.0
                    .visit_str(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
                self.0
                    .visit_borrowed_str(value)
                    .map_err(crate::kv::Error::into_value)
            }

            fn visit_char(&mut self, value: char) -> Result<(), Error> {
                self.0
                    .visit_char(value)
                    .map_err(crate::kv::Error::into_value)
            }

            #[cfg(feature = "kv_std")]
            fn visit_error(
                &mut self,
                err: &(dyn std::error::Error + 'static),
            ) -> Result<(), Error> {
                self.0
                    .visit_error(err)
                    .map_err(crate::kv::Error::into_value)
            }

            #[cfg(feature = "kv_std")]
            fn visit_borrowed_error(
                &mut self,
                err: &'v (dyn std::error::Error + 'static),
            ) -> Result<(), Error> {
                self.0
                    .visit_borrowed_error(err)
                    .map_err(crate::kv::Error::into_value)
            }
        }

        inner
            .visit(&mut InnerVisitValue(visitor))
            .map_err(crate::kv::Error::from_value)
    }
}

#[cfg(not(feature = "value-bag"))]
pub(in crate::kv) mod inner {
    /**
    This is a dependency-free implementation of `Value` when there's no serialization frameworks involved.
    In these simple cases a more fully featured solution like `value_bag` isn't needed, so we avoid pulling it in.

    There are a few things here that need to remain consistent with the `value_bag`-based implementation:

    1. Conversions should always produce the same results. If a conversion here returns `Some`, then
       the same `value_bag`-based conversion must also. Of particular note here are floats to ints; they're
       based on the standard library's `TryInto` conversions, which need to be converted to `i32` or `u32`,
       and then to `f64`.
    2. VisitValues should always be called in the same way. If a particular type of value calls `visit_i64`,
       then the same `value_bag`-based visitor must also.
    */
    use super::*;

    #[derive(Clone)]
    pub enum Inner<'v> {
        // NOTE: New variants can't be added here; see the module-level doc above
        None,
        Bool(bool),
        Str(&'v str),
        Char(char),
        I64(i64),
        U64(u64),
        F64(f64),
        I128(i128),
        U128(u128),
        Debug(&'v dyn fmt::Debug),
        Display(&'v dyn fmt::Display),
    }

    impl<'v> From<()> for Inner<'v> {
        fn from(_: ()) -> Self {
            Inner::None
        }
    }

    impl<'v> From<bool> for Inner<'v> {
        fn from(v: bool) -> Self {
            Inner::Bool(v)
        }
    }

    impl<'v> From<char> for Inner<'v> {
        fn from(v: char) -> Self {
            Inner::Char(v)
        }
    }

    impl<'v> From<f32> for Inner<'v> {
        fn from(v: f32) -> Self {
            Inner::F64(v as f64)
        }
    }

    impl<'v> From<f64> for Inner<'v> {
        fn from(v: f64) -> Self {
            Inner::F64(v)
        }
    }

    impl<'v> From<i8> for Inner<'v> {
        fn from(v: i8) -> Self {
            Inner::I64(v as i64)
        }
    }

    impl<'v> From<i16> for Inner<'v> {
        fn from(v: i16) -> Self {
            Inner::I64(v as i64)
        }
    }

    impl<'v> From<i32> for Inner<'v> {
        fn from(v: i32) -> Self {
            Inner::I64(v as i64)
        }
    }

    impl<'v> From<i64> for Inner<'v> {
        fn from(v: i64) -> Self {
            Inner::I64(v as i64)
        }
    }

    impl<'v> From<isize> for Inner<'v> {
        fn from(v: isize) -> Self {
            Inner::I64(v as i64)
        }
    }

    impl<'v> From<u8> for Inner<'v> {
        fn from(v: u8) -> Self {
            Inner::U64(v as u64)
        }
    }

    impl<'v> From<u16> for Inner<'v> {
        fn from(v: u16) -> Self {
            Inner::U64(v as u64)
        }
    }

    impl<'v> From<u32> for Inner<'v> {
        fn from(v: u32) -> Self {
            Inner::U64(v as u64)
        }
    }

    impl<'v> From<u64> for Inner<'v> {
        fn from(v: u64) -> Self {
            Inner::U64(v as u64)
        }
    }

    impl<'v> From<usize> for Inner<'v> {
        fn from(v: usize) -> Self {
            Inner::U64(v as u64)
        }
    }

    impl<'v> From<i128> for Inner<'v> {
        fn from(v: i128) -> Self {
            Inner::I128(v)
        }
    }

    impl<'v> From<u128> for Inner<'v> {
        fn from(v: u128) -> Self {
            Inner::U128(v)
        }
    }

    impl<'v> From<&'v str> for Inner<'v> {
        fn from(v: &'v str) -> Self {
            Inner::Str(v)
        }
    }

    impl<'v> fmt::Debug for Inner<'v> {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            match self {
                Inner::None => fmt::Debug::fmt(&None::<()>, f),
                Inner::Bool(v) => fmt::Debug::fmt(v, f),
                Inner::Str(v) => fmt::Debug::fmt(v, f),
                Inner::Char(v) => fmt::Debug::fmt(v, f),
                Inner::I64(v) => fmt::Debug::fmt(v, f),
                Inner::U64(v) => fmt::Debug::fmt(v, f),
                Inner::F64(v) => fmt::Debug::fmt(v, f),
                Inner::I128(v) => fmt::Debug::fmt(v, f),
                Inner::U128(v) => fmt::Debug::fmt(v, f),
                Inner::Debug(v) => fmt::Debug::fmt(v, f),
                Inner::Display(v) => fmt::Display::fmt(v, f),
            }
        }
    }

    impl<'v> fmt::Display for Inner<'v> {
        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
            match self {
                Inner::None => fmt::Debug::fmt(&None::<()>, f),
                Inner::Bool(v) => fmt::Display::fmt(v, f),
                Inner::Str(v) => fmt::Display::fmt(v, f),
                Inner::Char(v) => fmt::Display::fmt(v, f),
                Inner::I64(v) => fmt::Display::fmt(v, f),
                Inner::U64(v) => fmt::Display::fmt(v, f),
                Inner::F64(v) => fmt::Display::fmt(v, f),
                Inner::I128(v) => fmt::Display::fmt(v, f),
                Inner::U128(v) => fmt::Display::fmt(v, f),
                Inner::Debug(v) => fmt::Debug::fmt(v, f),
                Inner::Display(v) => fmt::Display::fmt(v, f),
            }
        }
    }

    impl<'v> Inner<'v> {
        pub fn from_debug<T: fmt::Debug>(value: &'v T) -> Self {
            Inner::Debug(value)
        }

        pub fn from_display<T: fmt::Display>(value: &'v T) -> Self {
            Inner::Display(value)
        }

        pub fn from_dyn_debug(value: &'v dyn fmt::Debug) -> Self {
            Inner::Debug(value)
        }

        pub fn from_dyn_display(value: &'v dyn fmt::Display) -> Self {
            Inner::Display(value)
        }

        pub fn empty() -> Self {
            Inner::None
        }

        pub fn to_bool(&self) -> Option<bool> {
            match self {
                Inner::Bool(v) => Some(*v),
                _ => None,
            }
        }

        pub fn to_char(&self) -> Option<char> {
            match self {
                Inner::Char(v) => Some(*v),
                _ => None,
            }
        }

        pub fn to_f64(&self) -> Option<f64> {
            match self {
                Inner::F64(v) => Some(*v),
                Inner::I64(v) => {
                    let v: i32 = (*v).try_into().ok()?;
                    v.try_into().ok()
                }
                Inner::U64(v) => {
                    let v: u32 = (*v).try_into().ok()?;
                    v.try_into().ok()
                }
                Inner::I128(v) => {
                    let v: i32 = (*v).try_into().ok()?;
                    v.try_into().ok()
                }
                Inner::U128(v) => {
                    let v: u32 = (*v).try_into().ok()?;
                    v.try_into().ok()
                }
                _ => None,
            }
        }

        pub fn to_i64(&self) -> Option<i64> {
            match self {
                Inner::I64(v) => Some(*v),
                Inner::U64(v) => (*v).try_into().ok(),
                Inner::I128(v) => (*v).try_into().ok(),
                Inner::U128(v) => (*v).try_into().ok(),
                _ => None,
            }
        }

        pub fn to_u64(&self) -> Option<u64> {
            match self {
                Inner::U64(v) => Some(*v),
                Inner::I64(v) => (*v).try_into().ok(),
                Inner::I128(v) => (*v).try_into().ok(),
                Inner::U128(v) => (*v).try_into().ok(),
                _ => None,
            }
        }

        pub fn to_u128(&self) -> Option<u128> {
            match self {
                Inner::U128(v) => Some(*v),
                Inner::I64(v) => (*v).try_into().ok(),
                Inner::U64(v) => (*v).try_into().ok(),
                Inner::I128(v) => (*v).try_into().ok(),
                _ => None,
            }
        }

        pub fn to_i128(&self) -> Option<i128> {
            match self {
                Inner::I128(v) => Some(*v),
                Inner::I64(v) => (*v).try_into().ok(),
                Inner::U64(v) => (*v).try_into().ok(),
                Inner::U128(v) => (*v).try_into().ok(),
                _ => None,
            }
        }

        pub fn to_borrowed_str(&self) -> Option<&'v str> {
            match self {
                Inner::Str(v) => Some(v),
                _ => None,
            }
        }

        #[cfg(test)]
        pub fn to_test_token(&self) -> Token<'_> {
            match self {
                Inner::None => Token::None,
                Inner::Bool(v) => Token::Bool(*v),
                Inner::Str(v) => Token::Str(*v),
                Inner::Char(v) => Token::Char(*v),
                Inner::I64(v) => Token::I64(*v),
                Inner::U64(v) => Token::U64(*v),
                Inner::F64(v) => Token::F64(*v),
                Inner::I128(_) => unimplemented!(),
                Inner::U128(_) => unimplemented!(),
                Inner::Debug(_) => unimplemented!(),
                Inner::Display(_) => unimplemented!(),
            }
        }
    }

    #[cfg(test)]
    #[derive(Debug, PartialEq)]
    pub enum Token<'v> {
        None,
        Bool(bool),
        Char(char),
        Str(&'v str),
        F64(f64),
        I64(i64),
        U64(u64),
    }

    pub fn visit<'v>(
        inner: &Inner<'v>,
        mut visitor: impl VisitValue<'v>,
    ) -> Result<(), crate::kv::Error> {
        match inner {
            Inner::None => visitor.visit_null(),
            Inner::Bool(v) => visitor.visit_bool(*v),
            Inner::Str(v) => visitor.visit_borrowed_str(*v),
            Inner::Char(v) => visitor.visit_char(*v),
            Inner::I64(v) => visitor.visit_i64(*v),
            Inner::U64(v) => visitor.visit_u64(*v),
            Inner::F64(v) => visitor.visit_f64(*v),
            Inner::I128(v) => visitor.visit_i128(*v),
            Inner::U128(v) => visitor.visit_u128(*v),
            Inner::Debug(v) => visitor.visit_any(Value::from_dyn_debug(*v)),
            Inner::Display(v) => visitor.visit_any(Value::from_dyn_display(*v)),
        }
    }
}

impl<'v> Value<'v> {
    /// Get a value from a type implementing `std::fmt::Debug`.
    #[cfg(feature = "kv_unstable")]
    #[deprecated(note = "use `from_debug` instead")]
    pub fn capture_debug<T>(value: &'v T) -> Self
    where
        T: fmt::Debug + 'static,
    {
        Value::from_debug(value)
    }

    /// Get a value from a type implementing `std::fmt::Display`.
    #[cfg(feature = "kv_unstable")]
    #[deprecated(note = "use `from_display` instead")]
    pub fn capture_display<T>(value: &'v T) -> Self
    where
        T: fmt::Display + 'static,
    {
        Value::from_display(value)
    }

    /// Get a value from an error.
    #[cfg(feature = "kv_unstable_std")]
    #[deprecated(note = "use `from_dyn_error` instead")]
    pub fn capture_error<T>(err: &'v T) -> Self
    where
        T: std::error::Error + 'static,
    {
        Value::from_dyn_error(err)
    }

    /// Get a value from a type implementing `serde::Serialize`.
    #[cfg(feature = "kv_unstable_serde")]
    #[deprecated(note = "use `from_serde` instead")]
    pub fn capture_serde<T>(value: &'v T) -> Self
    where
        T: serde_core::Serialize + 'static,
    {
        Value::from_serde(value)
    }

    /// Get a value from a type implementing `sval::Value`.
    #[cfg(feature = "kv_unstable_sval")]
    #[deprecated(note = "use `from_sval` instead")]
    pub fn capture_sval<T>(value: &'v T) -> Self
    where
        T: sval::Value + 'static,
    {
        Value::from_sval(value)
    }

    /// Check whether this value can be downcast to `T`.
    #[cfg(feature = "kv_unstable")]
    #[deprecated(
        note = "downcasting has been removed; log an issue at https://github.com/rust-lang/log/issues if this is something you rely on"
    )]
    pub fn is<T: 'static>(&self) -> bool {
        false
    }

    /// Try downcast this value to `T`.
    #[cfg(feature = "kv_unstable")]
    #[deprecated(
        note = "downcasting has been removed; log an issue at https://github.com/rust-lang/log/issues if this is something you rely on"
    )]
    pub fn downcast_ref<T: 'static>(&self) -> Option<&T> {
        None
    }
}

// NOTE: Deprecated; but aliases can't carry this attribute
#[cfg(feature = "kv_unstable")]
pub use VisitValue as Visit;

/// Get a value from a type implementing `std::fmt::Debug`.
#[cfg(feature = "kv_unstable")]
#[deprecated(note = "use the `key:? = value` macro syntax instead")]
#[macro_export]
macro_rules! as_debug {
    ($capture:expr) => {
        $crate::kv::Value::from_debug(&$capture)
    };
}

/// Get a value from a type implementing `std::fmt::Display`.
#[cfg(feature = "kv_unstable")]
#[deprecated(note = "use the `key:% = value` macro syntax instead")]
#[macro_export]
macro_rules! as_display {
    ($capture:expr) => {
        $crate::kv::Value::from_display(&$capture)
    };
}

/// Get a value from an error.
#[cfg(feature = "kv_unstable_std")]
#[deprecated(note = "use the `key:err = value` macro syntax instead")]
#[macro_export]
macro_rules! as_error {
    ($capture:expr) => {
        $crate::kv::Value::from_dyn_error(&$capture)
    };
}

#[cfg(feature = "kv_unstable_serde")]
#[deprecated(note = "use the `key:serde = value` macro syntax instead")]
/// Get a value from a type implementing `serde::Serialize`.
#[macro_export]
macro_rules! as_serde {
    ($capture:expr) => {
        $crate::kv::Value::from_serde(&$capture)
    };
}

/// Get a value from a type implementing `sval::Value`.
#[cfg(feature = "kv_unstable_sval")]
#[deprecated(note = "use the `key:sval = value` macro syntax instead")]
#[macro_export]
macro_rules! as_sval {
    ($capture:expr) => {
        $crate::kv::Value::from_sval(&$capture)
    };
}

#[cfg(test)]
pub(crate) mod tests {
    use super::*;

    // For new `ToValue` implementations, also add a test to the `tests/macros` file

    impl<'v> Value<'v> {
        #[allow(mismatched_lifetime_syntaxes)]
        pub(crate) fn to_token(&self) -> inner::Token {
            self.inner.to_test_token()
        }
    }

    fn unsigned() -> impl Iterator<Item = Value<'static>> {
        vec![
            Value::from(8u8),
            Value::from(16u16),
            Value::from(32u32),
            Value::from(64u64),
            Value::from(1usize),
            Value::from(std::num::NonZeroU8::new(8).unwrap()),
            Value::from(std::num::NonZeroU16::new(16).unwrap()),
            Value::from(std::num::NonZeroU32::new(32).unwrap()),
            Value::from(std::num::NonZeroU64::new(64).unwrap()),
            Value::from(std::num::NonZeroUsize::new(1).unwrap()),
        ]
        .into_iter()
    }

    fn signed() -> impl Iterator<Item = Value<'static>> {
        vec![
            Value::from(-8i8),
            Value::from(-16i16),
            Value::from(-32i32),
            Value::from(-64i64),
            Value::from(-1isize),
            Value::from(std::num::NonZeroI8::new(-8).unwrap()),
            Value::from(std::num::NonZeroI16::new(-16).unwrap()),
            Value::from(std::num::NonZeroI32::new(-32).unwrap()),
            Value::from(std::num::NonZeroI64::new(-64).unwrap()),
            Value::from(std::num::NonZeroIsize::new(-1).unwrap()),
        ]
        .into_iter()
    }

    fn float() -> impl Iterator<Item = Value<'static>> {
        vec![Value::from(32.32f32), Value::from(64.64f64)].into_iter()
    }

    fn bool() -> impl Iterator<Item = Value<'static>> {
        vec![Value::from(true), Value::from(false)].into_iter()
    }

    fn str() -> impl Iterator<Item = Value<'static>> {
        vec![Value::from("a string"), Value::from("a loong string")].into_iter()
    }

    fn char() -> impl Iterator<Item = Value<'static>> {
        vec![Value::from('a'), Value::from('⛰')].into_iter()
    }

    #[test]
    fn test_to_value_display() {
        assert_eq!(42u64.to_value().to_string(), "42");
        assert_eq!(42i64.to_value().to_string(), "42");
        assert_eq!(42.01f64.to_value().to_string(), "42.01");
        assert_eq!(true.to_value().to_string(), "true");
        assert_eq!('a'.to_value().to_string(), "a");
        assert_eq!("a loong string".to_value().to_string(), "a loong string");
        assert_eq!(Some(true).to_value().to_string(), "true");
        assert_eq!(().to_value().to_string(), "None");
        assert_eq!(None::<bool>.to_value().to_string(), "None");
    }

    #[test]
    #[cfg(feature = "std")]
    fn test_net_to_value_display() {
        use std::str::FromStr;

        assert_eq!(
            std::net::Ipv4Addr::new(192, 168, 10, 100)
                .to_value()
                .to_string(),
            "192.168.10.100"
        );
        assert_eq!(
            std::net::Ipv6Addr::from_str("f33c::1")
                .unwrap()
                .to_value()
                .to_string(),
            "f33c::1"
        );
        assert_eq!(
            std::net::IpAddr::V4(std::net::Ipv4Addr::new(192, 168, 10, 100))
                .to_value()
                .to_string(),
            "192.168.10.100"
        );
        assert_eq!(
            std::net::IpAddr::V6(std::net::Ipv6Addr::from_str("f33c::1").unwrap())
                .to_value()
                .to_string(),
            "f33c::1"
        );
        assert_eq!(
            std::net::SocketAddrV4::new(std::net::Ipv4Addr::new(192, 168, 10, 100), 12345)
                .to_value()
                .to_string(),
            "192.168.10.100:12345"
        );
        assert_eq!(
            std::net::SocketAddrV6::new(
                std::net::Ipv6Addr::from_str("f33c::1").unwrap(),
                12345,
                0,
                0
            )
            .to_value()
            .to_string(),
            "[f33c::1]:12345"
        );
        assert_eq!(
            std::net::SocketAddr::V4(std::net::SocketAddrV4::new(
                std::net::Ipv4Addr::new(192, 168, 10, 100),
                12345
            ))
            .to_value()
            .to_string(),
            "192.168.10.100:12345"
        );
        assert_eq!(
            std::net::SocketAddr::V6(std::net::SocketAddrV6::new(
                std::net::Ipv6Addr::from_str("f33c::1").unwrap(),
                12345,
                0,
                0
            ))
            .to_value()
            .to_string(),
            "[f33c::1]:12345"
        );
    }

    #[test]
    fn test_to_value_structured() {
        assert_eq!(42u64.to_value().to_token(), inner::Token::U64(42));
        assert_eq!(42i64.to_value().to_token(), inner::Token::I64(42));
        assert_eq!(42.01f64.to_value().to_token(), inner::Token::F64(42.01));
        assert_eq!(true.to_value().to_token(), inner::Token::Bool(true));
        assert_eq!('a'.to_value().to_token(), inner::Token::Char('a'));
        assert_eq!(
            "a loong string".to_value().to_token(),
            inner::Token::Str("a loong string".into())
        );
        assert_eq!(Some(true).to_value().to_token(), inner::Token::Bool(true));
        assert_eq!(().to_value().to_token(), inner::Token::None);
        assert_eq!(None::<bool>.to_value().to_token(), inner::Token::None);
    }

    #[test]
    fn test_to_number() {
        for v in unsigned() {
            assert!(v.to_u64().is_some());
            assert!(v.to_i64().is_some());
        }

        for v in signed() {
            assert!(v.to_i64().is_some());
        }

        for v in unsigned().chain(signed()).chain(float()) {
            assert!(v.to_f64().is_some());
        }

        for v in bool().chain(str()).chain(char()) {
            assert!(v.to_u64().is_none());
            assert!(v.to_i64().is_none());
            assert!(v.to_f64().is_none());
        }
    }

    #[test]
    fn test_to_float() {
        // Only integers from i32::MIN..=u32::MAX can be converted into floats
        assert!(Value::from(i32::MIN).to_f64().is_some());
        assert!(Value::from(u32::MAX).to_f64().is_some());

        assert!(Value::from((i32::MIN as i64) - 1).to_f64().is_none());
        assert!(Value::from((u32::MAX as u64) + 1).to_f64().is_none());
    }

    #[test]
    fn test_to_cow_str() {
        for v in str() {
            assert!(v.to_borrowed_str().is_some());

            #[cfg(feature = "kv_std")]
            assert!(v.to_cow_str().is_some());
        }

        let short_lived = String::from("short lived");
        let v = Value::from(&*short_lived);

        assert!(v.to_borrowed_str().is_some());

        #[cfg(feature = "kv_std")]
        assert!(v.to_cow_str().is_some());

        for v in unsigned().chain(signed()).chain(float()).chain(bool()) {
            assert!(v.to_borrowed_str().is_none());

            #[cfg(feature = "kv_std")]
            assert!(v.to_cow_str().is_none());
        }
    }

    #[test]
    fn test_to_bool() {
        for v in bool() {
            assert!(v.to_bool().is_some());
        }

        for v in unsigned()
            .chain(signed())
            .chain(float())
            .chain(str())
            .chain(char())
        {
            assert!(v.to_bool().is_none());
        }
    }

    #[test]
    fn test_to_char() {
        for v in char() {
            assert!(v.to_char().is_some());
        }

        for v in unsigned()
            .chain(signed())
            .chain(float())
            .chain(str())
            .chain(bool())
        {
            assert!(v.to_char().is_none());
        }
    }

    #[test]
    fn test_visit_integer() {
        struct Extract(Option<u64>);

        impl<'v> VisitValue<'v> for Extract {
            fn visit_any(&mut self, value: Value) -> Result<(), Error> {
                unimplemented!("unexpected value: {value:?}")
            }

            fn visit_u64(&mut self, value: u64) -> Result<(), Error> {
                self.0 = Some(value);

                Ok(())
            }
        }

        let mut extract = Extract(None);
        Value::from(42u64).visit(&mut extract).unwrap();

        assert_eq!(Some(42), extract.0);
    }

    #[test]
    fn test_visit_borrowed_str() {
        struct Extract<'v>(Option<&'v str>);

        impl<'v> VisitValue<'v> for Extract<'v> {
            fn visit_any(&mut self, value: Value) -> Result<(), Error> {
                unimplemented!("unexpected value: {value:?}")
            }

            fn visit_borrowed_str(&mut self, value: &'v str) -> Result<(), Error> {
                self.0 = Some(value);

                Ok(())
            }
        }

        let mut extract = Extract(None);

        let short_lived = String::from("A short-lived string");
        Value::from(&*short_lived).visit(&mut extract).unwrap();

        assert_eq!(Some("A short-lived string"), extract.0);
    }
}

Internet Society hay ISOC là một tổ chức quốc tế hoạt động phi lợi nhuận, phi chính phủ và bao gồm các thành viên có trình độ chuyên ngành. Tổ chức này chú trọng đến: tiêu chuẩn, giáo dục và các vấn đề về chính sách. Với trên 145 tổ chức thành viên và 65.000 thành viên cá nhân, ISOC bao gồm những con người cụ thể trong cộng đồng Internet. Mọi chi tiết có thể tìm thấy tại website của ISOC.

Internet Society nằm ở gần thủ đô Washington, DC, Hoa Kỳ và Geneva, Thụy Sĩ. Số hội viên của nó bao gồm hơn 145 tổ chức thành viên và hơn 65.000 cá nhân. Thành viên còn có thể tự lập một chi nhánh của tổ chức tùy theo vị trí hoặc sở thích. Hiện nay tổ chức có tới 90 chi nhánh trên toàn thế giới.

Nhiệm vụ và mục đích hoạt động
Bảo đảm, cổ vũ cho sự phát triển, mở rộng và sử dụng Internet được thuận lợi nhất cho mọi người trên toàn thế giới.

Xem thêm
Lịch sử Internet

Tham khảo

Liên kết ngoài
 
 
 ISOC Việt Nam
 IETF and the Internet Society - Về Internet Engineering Task Force và ISOC, bài của Vint Cerf 18/7/1995
 L’Association Internationale de Lutte Contre la Cybercriminalité bản lưu
 Public Interest Registry

Internet
Tổ chức quốc tế
Tổ chức phi lợi nhuận
Tiêu chuẩn Internet
Khởi đầu năm 1992
Quản lý Internet

သမိုင်းဆိုသည်မှာ လူသားတို့၏ အတိတ်ကာလကို လေ့လာသော ဘာသာရပ်ဖြစ်သည်။ စာရေးသားခြင်းကို တီထွင်ပြီးသည့်နောက်တွင် သမိုင်းပေါ်ပေါက်လာခဲ့သည်ဟုလည်း ဆိုနိုင်သည်။ သမိုင်းကို ရေးသားသော ပညာရှင်များကို သမိုင်းပညာရှင်ဟု ခေါ်ဆိုလေ့ရှိကြသည်။ ၎င်းမှာ ပြန်ပြောင်းပြောဆိုချက်များကို အသုံးပြု၍ ဆက်တိုက်ဖြစ်ပျက် ခဲ့သော အဖြစ်အပျက်များကို စစ်ဆေးခြင်းနှင့် ခွဲခြမ်းစိတ်ဖြာခြင်း ပြုသော သုတေသန နယ်ပယ် ဖြစ်ကာ တစ်ခါတရံတွင် အကျိုးအကြောင်း ဆက်နွယ်၍ ဖြစ်ပျက်ခဲ့သော အဖြစ်အပျက်များကို ဓမ္မဓိဋ္ဌာန်ကျကျ စုံစမ်းစစ်ဆေးကာ ဆုံးဖြတ်သော ပညာရပ်ပင် ဖြစ်သည်။ သမိုင်းပညာရှင်များသည် သမိုင်း၏ သဘောသဘာဝ နှင့် အသုံးဝင်မှုတို့ကို ငြင်းခုံလေ့ ရှိကြသည်။

မြန်မာ့စွယ်စုံကျမ်းမှ သမိုင်း 
သမိုင်းဟူသည်မှာ အတိတ်ကဖြစ်ရပ်များကိုလေ့လာမှတ်ကျောက်တင်ထားသောစာကိုဆိုလိုသည်။ ဘုရား၊ ဂူ၊ ကျောင်း၊ တန်ဆောင်း၊ စဆွံ၊ ဓမ္မသာလာ၊ တန်တား၊ ပုဂ္ဂိုလ်ထူး၊အကြောင်းအရာထူး စသည်တို့နှင့်စပ်လျဉ်း၍ စကားပြေဖြင့် ဖြစ်စေလင်္ကာဖြင့်ဖြစ်စေ စီကုံးရေးသားထားသည်များကိုသမိုင်းဟုခေါ်သည်။ 

အချို့ကလည်း သမိုင်းသည်သံပိုင်းနှင့်သဘောချင်းတူပြီးလျှင် သံပိုင်းမှသမ္ပိုင်း၊ သမိုင်းဖြစ်လာသည်ဟုဆိုကြသည်။ စကားပြေဖြင့်ရေးသားထားသော သမိုင်းများအကြောင်းကို အထူးမရေးသားတော့ဘဲ လင်္ကာစပ်ဆိုထားသောသမိုင်းရေးသားနည်းကိုဖော်ပြပေအံ့။ သမိုင်းလင်္ကာစပ်ဆိုရာ၌-
 လင်္ကာစပ်ဆိုနည်းများ အတိုင်းရေး သွားသည်။ 
 အစမှာဖြစ်စေ၊ အဆုံးမှာဖြစ်စေ သမိုင်းဟူသောစကား များသောအားဖြင့်ပါရှိတတ်သည်။ 

ပုံစံအားဖြင့်သမိုင်းတန်ဆောင်၊ ကမ္ပည်းဆောင်အံ့၊ ဉာဏ်ရောင်ဖြန့်ချိ၊နှိုင်းချိန်ညှိလော့၊လောကီအရာ စသည်ဖြင့် သမိုင်း လင်္ကာမှန်းသိအောင် သမိုင်းဆိုသည့်ပုဒ်ကို 
ထည့်စပ်လေ့ရှိကြသည်။ သမိုင်းဟူသည့်ပုဒ်ကိုလင်္ကာ၏ အလယ်၌သမိုင်းမှန်းသိအောင်ထည့်သွင်းစပ်ဆိုသည်လည်းရှိသည်။ ပုံစံအားဖြင့်စစ်ကိုင်းမြို့ သမိုင်းလင်္ကာတွင်
 ရန်မာန်ပယ်ခိုင်း၊မြို့စစ်ကိုင်း၏၊သမိုင်းလင်္ကာ၊ ဂုဏ်ကိုးဖြာအား ဟူ၍လည်းကောင်း၊ ရှင်ပင်သက်တော်ရဘုရားသမိုင်းတွင် မင်္ဂလာ ထုံးဆောင်၊ကပ်လုံးပြောင်စိမ့်၊ အခေါင်သာနှိုင်း၊ တပေါင်လှိုင်း၍၊တိုင်းမြန်မာပြည်၊ သမိုင်းရှည်ဖြင့်၊ ငါးမည်အင်စုံ ဟူ၍လည်းကောင်း အသီးသီးစပ်ဆိုကြသည်။ 

အချို့သမိုင်းလင်္ကာစာကိုယ်များ၌မူ သမိုင်းဟူသောစာပုဒ်လုံးဝ မပါပဲလည်းရှိတတ်သည်။ ပုံစံအားဖြင့်ပုဂံပညာရှိမွန်း
ကိုဆိုပုဂံမြို့ရှိဂူဘုရားစဉ်သမိုင်းလင်္ကာ၌မဉ္ဇူဘုန်းတော်၊ သောင်း လုံးကျော်သည်၊ ထိပ်ပေါ်အထွတ်၊ရွှေနားညွတ်လော့၊ ရိမဒ်ပေါက္ကံ၊ တမ္ပဝတီ၊ သီရိပစ္စယာ၊ ပုဏ္ဏဂါမ၊ပုဂါမမည်၊ ဤငါးပြည်၌၊ ဆက်ရှည်စံပယ်၊ ငါးဆယ်နှင့်ငါး၊ နရဖျားတို့၊တည်ထားပြုစု၊ ကောင်းမှုစေ့မျိုး၊ကြဲစိုက်ပျိုးသည်၊ ပုထိုးစေတီ၊လက်ချောင်းစီသို့ရ၍ ဤဖွယ်တည့်၊ များစွာရှိလည်း၊ တွေ့မိသ၍၊ မစုံစေ့ခဲ့၊ ဘုန်းဟေ့နတ်လူ၊ဉာဏ်တံချူဖြင့်၊ ဆွတ်ယူစိမ့်ငှာ၊ထိပ်ချာတင်ရွက်၊ သီကုံးဆက်သည်၊ရွှေခွက်သောတာရုံဘုရားဟူ၍ဖြစ်သည်။

သမိုင်းမဝင်၊ စာမတင်
သမိုင်းမဝင်၊ စာမတင်၊ ရွာပင်မခေါ်ရ ဟူသော စကားတစ်ရပ် ရှိသည်။ မည်သည့်မြို့ မည်သည့်ရွာ ဖြစ်စေ သမိုင်း ခေါ် ဖြစ်စဉ်ကမူ ရှိမြဲဖြစ်သည်။ လူတို့က မသိ၍သာ မြုပ်ကွယ်နေမည်။ ဖြစ်စဉ်သမိုင်းကမူ ရွှံ့အိုင်အတွင်း၌ အနားယူနေသော ပတ္တမြား ရတနာသဖွယ် ဖြစ်ရာသည်။ 

သမိုင်း ဟူသော ဝေါဟာရကို မြန်မာဘာသာ စစ်စစ်ဟု ဆိုသူတို့က သမိုင်း (မိုင်း = ကြီးမား) သိဖွယ်ရာကြီး တစ်ရပ်ဟု အဓိပ္ပာယ်ဆိုသည်။ သမိုင်းဆိုလျင် သိရမည်။ သိအောင်ပြုရမည်ဟု ဆိုလိုသည်။ 

သမိုင်းကို ပါဠိဘာသာမှ ဆင်းသက်သည်ဟု ဆိုသူတို့က သမုတိ ဟူသော ပုဒ်မှလည်းကောင်း၊ သမ္မုတိ ဟူသော ပုဒ်မှလည်းကောင်း ဖြစ်သည်ဟု ဆို၏။ သမုတိမှ သံ - မညတေတိ၊ သမုတိ၊ သမ္မုတိမှ သမ္မနနံ-သမ္မုတိ ဟု ဝိဂြိုဟ် အသီးသီးဆိုကာ - သံပုဗ္ဗ မနဓာတ်ဖြင့် ကောင်းစွာသိခြင်းကိုချည်း ပြသည်။ သို့သော် သမိုင်းကို ပါဠိဘာသာမှ ဆင်းသက်ခြင်း မဟုတ်ဟု ယူဆကာ ပါဠိပညာရှင်များက သမုတိ၊ သမ္မုတိ များဖြင့် အဓိပ္ပာယ် မဖော်လိုကြပေ။ နာမည်ကျော် ပါဠိသက် အဘိဓာန်များကလည်း ယင်းကို လျစ်လျူရှုခဲ့ကြသည်။ 

သမိုင်းဟူသည် သိမှတ်ဖွယ်ရာ စာပေ, ကဗျာဖြစ်၍ မသိမဖြစ်၊ သိကိုသိရမည့်၊ မှတ်ကို မှတ်ရမည့် အကြောင်းအရာများပင် ဖြစ်သည်။ ဘုရားသမိုင်း၊ ကျောင်းသမိုင်း၊ မြို့သမိုင်း၊ ရွာသမိုင်း၊ လူ့သမိုင်း၊ အဖွဲ့အစည်းသမိုင်း၊ အသင်းအပင်းသမိုင်း၊ စာပေသမိုင်း စသည့် အဆောက်အအုံ မြို့ရွာ အရာဝတ္ထု အစုအစည်း အားလုံး၏ သိမှတ်ဖွယ်ရာ ရှေးအစူအစဉ်များပင် ဖြစ်ကြောင်း ထင်ရှားလှပါသည်။ ထို့ကြောင့် မြန်မာနိုင်ငံတွင် သမိုင်းဟူသည် မြန်မာစာပေ၌ အရေးကြီးသော အပိုင်းတစ်ပိုင်းအဖြစ် ပါဝင်လာရသည်။ မြန်မာစာပေအတွင်းမှ သမိုင်းဟူသည်ကို နုတ်လိုက်လျှင် လက်ကျန်အနည်းငယ်မျှသာ ကြွင်းကျန်လိမ့်မည်ဟု ယူဆရပေသည်။ သမိုင်းကိုလည်း မြန်မာစာပေမှ အဆီညှစ်၍ အနှစ်ကို ထုတ်ကာ ရွေးကောက်ရသည် ဖြစ်ရာ စာပေနှင့် သမိုင်းသည် မကင်းရာ မကင်းကြောင်းပင် ဖြစ်သည်။ 

သမိုင်းမဝင်၍ စာမတင်ခဲ့သလို၊ စာမတင်ခဲ့၍လည်း သမိုင်းဟူ၍ မဝင် မဖြစ်ပေါ်သည်လည်း ရှိသည်။ သမိုင်းဝင်ပါလျက် စာမတင်၍လည်း သမိုင်းအစပျောက်ကာ နောက်လူတို့ မသိမမြင်ကြရသည်ကလည်း ရှိပေသည်။ အမှန်အားဖြင့်ဆိုသော် ဤအချက်က ပို၍များ၏။ စာမတင်ခဲ့ရ၍ သမိုင်းမဖြစ်ခဲ့ရသည်မှာ မြန်မာနိုင်ငံတွင် ဒုနှင့်ဒေး အများအပြားဖြစ်၏။

ကိုးကား 

သမိုင်း
ပင်မ အကြောင်းအရာ ဆောင်းပါးများ

from __future__ import annotations

import re
import sys

import pytest

import click
from click._compat import _ansi_re
from click._compat import strip_ansi
from click._compat import term_len
from click._textwrap import _truncate_visible

ESC = "\033"

# Inventory of every escape sequence Click itself emits. ``strip_ansi`` must
# keep removing all of them.
CLICK_EMITTED = [
    # SGR foreground/background, the basic 16 colors.
    f"{ESC}[30m",
    f"{ESC}[37m",
    f"{ESC}[40m",
    f"{ESC}[47m",
    # SGR 256-color and true-color (Click renders these with semicolons).
    f"{ESC}[38;5;200m",
    f"{ESC}[48;5;91m",
    f"{ESC}[38;2;255;12;128m",
    f"{ESC}[48;2;135;0;175m",
    # SGR attributes and their resets.
    f"{ESC}[1m",
    f"{ESC}[22m",
    f"{ESC}[4m",
    f"{ESC}[24m",
    f"{ESC}[53m",
    f"{ESC}[55m",
    f"{ESC}[9m",
    f"{ESC}[29m",
    # Reset-all appended by style().
    f"{ESC}[0m",
    # Screen clear and cursor home from click.clear().
    f"{ESC}[2J",
    f"{ESC}[1;1H",
    # Cursor hide/show around the progress bar.
    f"{ESC}[?25l",
    f"{ESC}[?25h",
]

# CSI sequences Click never emits but may receive from other tooling.
CSI_FOREIGN = [
    # Colon-delimited (ISO 8613-6) true-color and 256-color SGR.
    f"{ESC}[38:2:255:0:0m",
    f"{ESC}[38:5:200m",
    f"{ESC}[1;38:2::255:0:0m",  # empty colon field is a valid parameter
    # SGR mouse reporting (the ``<`` parameter byte is 0x3C).
    f"{ESC}[<0;30;40M",
    f"{ESC}[<0;30;40m",
    # Private-mode set/reset with a multi-digit parameter.
    f"{ESC}[?1049h",
    f"{ESC}[?1049l",
    # Cursor-shape select: an intermediate byte (space, 0x20) before final ``q``.
    f"{ESC}[0 q",
    f"{ESC}[2 q",
    # Set scrolling region: a non-``m`` letter final byte.
    f"{ESC}[1;24r",
    # Function-key / bracketed-paste codes ending in ``~`` (0x7E).
    f"{ESC}[3~",
    f"{ESC}[200~",
    # Empty parameter list (``ESC [ m`` is a valid reset).
    f"{ESC}[m",
]

# The previous pattern, kept here to prove the new one is a superset.
_LEGACY_ANSI_RE = re.compile(r"\033\[[;?0-9]*[a-zA-Z]")


def test_is_jupyter_kernel_output():
    class JupyterKernelFakeStream:
        pass

    # implementation detail, aka cheapskate test
    JupyterKernelFakeStream.__module__ = "ipykernel.faked"
    assert click._compat._is_jupyter_kernel_output(stream=JupyterKernelFakeStream())


@pytest.mark.parametrize(
    "stream",
    [None, sys.stdin, sys.stderr, sys.stdout],
)
@pytest.mark.parametrize(
    ("color", "expected_override"),
    [
        (True, False),
        (False, True),
        (None, None),
    ],
)
@pytest.mark.parametrize(
    ("isatty", "is_jupyter", "expected"),
    [
        (True, False, False),
        (False, True, False),
        (False, False, True),
    ],
)
def test_should_strip_ansi(
    monkeypatch,
    stream,
    color: bool | None,
    expected_override: bool | None,
    isatty: bool,
    is_jupyter: bool,
    expected: bool,
) -> None:
    monkeypatch.setattr(click._compat, "isatty", lambda x: isatty)
    monkeypatch.setattr(
        click._compat, "_is_jupyter_kernel_output", lambda x: is_jupyter
    )

    if expected_override is not None:
        expected = expected_override
    assert click._compat.should_strip_ansi(stream=stream, color=color) == expected


@pytest.mark.parametrize("seq", CLICK_EMITTED + CSI_FOREIGN)
def test_strip_ansi_removes_full_sequence(seq):
    """Every complete CSI sequence is stripped, alone or wrapped in text."""
    assert strip_ansi(seq) == ""
    assert strip_ansi(f"a{seq}b") == "ab"
    assert term_len(f"a{seq}b") == 2


@pytest.mark.parametrize("final", ["m", "H", "J", "A", "z"])
@pytest.mark.parametrize("params", ["", "0", "1;2", ";", "?25", "0;0;0"])
def test_strip_ansi_is_superset_of_legacy(params, final):
    """Everything the legacy pattern stripped, the CSI grammar still strips."""
    seq = f"{ESC}[{params}{final}"
    assert _LEGACY_ANSI_RE.fullmatch(seq) is not None
    assert strip_ansi(seq) == ""
    assert strip_ansi(f"a{seq}b") == "ab"


@pytest.mark.parametrize(
    ("text", "expected"),
    [
        (f"{ESC}[31mred{ESC}[0m", "red"),
        (f"a{ESC}[38:2:1:2:3mb{ESC}[0mc", "abc"),
        (f"{ESC}[?25l{ESC}[2Jhidden{ESC}[?25h", "hidden"),
        (f"{ESC}[<0;1;1Mclick{ESC}[<0;1;1m", "click"),
        # Several adjacent sequences around each visible character.
        (f"{ESC}[1m{ESC}[31mA{ESC}[0m {ESC}[32mB{ESC}[0m", "A B"),
        # Real terminal captures ported from the boltons strip_ansi tests.
        # ANSI art fragment (its doctest example).
        (f"{ESC}[0m{ESC}[1;36mart{ESC}[46;34m\xdc", "art\xdc"),
        # `ls` color output, ending on a dangling SGR with no text after it.
        (
            f"ls\r\n{ESC}[00m{ESC}[01;31mfile.zip{ESC}[00m\r\n{ESC}[01;31m",
            "ls\r\nfile.zip\r\n",
        ),
        # Tab-separated colorized fields.
        (f"\t{ESC}[0;35mIP{ESC}[0m\t{ESC}[0;36m192.1.0.2{ESC}[0m", "\tIP\t192.1.0.2"),
        # A styled cell inside a box-drawing table.
        (
            f"╒══════╕\n│ {ESC}[1mCell{ESC}[0m │\n╘══════╛",
            "╒══════╕\n│ Cell │\n╘══════╛",
        ),
        # Kaomoji with a bolded run.
        (f"(╯°□°)╯︵ {ESC}[1m┻━┻{ESC}[0m", "(╯°□°)╯︵ ┻━┻"),
    ],
)
def test_strip_ansi_mixed_content(text, expected):
    assert strip_ansi(text) == expected
    assert term_len(text) == len(expected)


def test_strip_ansi_stops_at_final_byte():
    """The match ends at the first final byte."""
    assert strip_ansi(f"{ESC}[31mX{ESC}[0mY") == "XY"
    assert strip_ansi(f"{ESC}[1m{ESC}[31mZ") == "Z"
    # The final ``m`` ends the sequence; the following ``;1m`` is plain text.
    assert strip_ansi(f"{ESC}[m;1m") == ";1m"


@pytest.mark.parametrize(
    "text",
    [
        "",
        "plain text",
        "100% [done]",
        "array[0] = 1",
        "a;b;c",
        # Looks like SGR parameters but lacks the ESC introducer.
        "[38;5;200m not an escape",
        "[0m",
    ],
)
def test_strip_ansi_leaves_plain_text(text):
    """Text that merely resembles an escape sequence is never stripped."""
    assert strip_ansi(text) == text
    assert term_len(text) == len(text)


@pytest.mark.parametrize(
    "text",
    [
        f"{ESC}",  # lone ESC
        f"{ESC}[",  # CSI introducer with no final byte
        f"{ESC}[31",  # parameters but no final byte
        f"{ESC}[38:2:1",  # colon parameters, truncated
        f"{ESC}[0 ",  # intermediate byte but no final byte
    ],
)
def test_strip_ansi_leaves_incomplete_sequences(text):
    """An unterminated sequence (missing its final byte) is left untouched."""
    assert strip_ansi(text) == text


def test_strip_ansi_is_idempotent():
    text = f"{ESC}[38:2:1:2:3mhi{ESC}[0m {ESC}[<0;1;1mthere{ESC}[?25h"
    once = strip_ansi(text)
    assert once == "hi there"
    assert strip_ansi(once) == once


@pytest.mark.parametrize(
    ("text", "visible"),
    [
        ("", 0),
        ("plain", 5),
        (f"{ESC}[31mred{ESC}[0m", 3),
        (f"{ESC}[38;2;1;2;3mrgb{ESC}[0m", 3),
        (f"{ESC}[38:2:1:2:3mrgb{ESC}[0m", 3),
        (f"{ESC}[<0;1;1Mx{ESC}[<0;1;1m", 1),
        (f"{ESC}[0 qq", 1),
        (f"{ESC}[?25lvisible{ESC}[?25h", 7),
        (f"{ESC}[1m{ESC}[4m{ESC}[31mhello{ESC}[0m", 5),
    ],
)
def test_term_len(text, visible):
    assert term_len(text) == visible


@pytest.mark.parametrize("seq", CLICK_EMITTED + CSI_FOREIGN)
def test_ansi_re_matches_whole_sequence(seq):
    """``_ansi_re`` matches a complete sequence end to end as one token."""
    m = _ansi_re.match(seq)
    assert m is not None
    assert m.start() == 0
    assert m.end() == len(seq)


@pytest.mark.parametrize(
    ("text", "n", "expected"),
    [
        # No escapes: behaves like a plain prefix slice.
        ("abcdef", 3, "abc"),
        ("abc", 10, "abc"),
        ("abc", 0, ""),
        ("abc", -1, ""),
        # A leading escape is kept and does not count toward the budget.
        (f"{ESC}[31mabcdef{ESC}[0m", 3, f"{ESC}[31mabc"),
        # A colon true-color escape stays intact; the cut lands after 3 chars.
        (f"{ESC}[38:2:1:2:3mabcdef", 3, f"{ESC}[38:2:1:2:3mabc"),
        # A trailing escape past the cut is not pulled in.
        (f"{ESC}[31mabc{ESC}[0m", 3, f"{ESC}[31mabc"),
    ],
)
def test_truncate_visible(text, n, expected):
    out = _truncate_visible(text, n)
    assert out == expected
    assert term_len(out) <= max(n, 0)

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os
import re
from cpt.packager import ConanMultiPackager
from cpt.ci_manager import CIManager
from cpt.printer import Printer


class BuilderSettings(object):
    @property
    def username(self):
        """ Set catchorg as package's owner
        """
        return os.getenv("CONAN_USERNAME", "catchorg")

    @property
    def login_username(self):
        """ Set Bintray login username
        """
        return os.getenv("CONAN_LOGIN_USERNAME", "horenmar")

    @property
    def upload(self):
        """ Set Catch2 repository to be used on upload.
            The upload server address could be customized by env var
            CONAN_UPLOAD. If not defined, the method will check the branch name.
            Only devel or CONAN_STABLE_BRANCH_PATTERN will be accepted.
            The devel branch will be pushed to testing channel, because it does
            not match the stable pattern. Otherwise it will upload to stable
            channel.
        """
        return os.getenv("CONAN_UPLOAD", "https://api.bintray.com/conan/catchorg/catch2")

    @property
    def upload_only_when_stable(self):
        """ Force to upload when running over tag branch
        """
        return os.getenv("CONAN_UPLOAD_ONLY_WHEN_STABLE", "True").lower() in ["true", "1", "yes"]

    @property
    def stable_branch_pattern(self):
        """ Only upload the package the branch name is like a tag
        """
        return os.getenv("CONAN_STABLE_BRANCH_PATTERN", r"v\d+\.\d+\.\d+")

    @property
    def reference(self):
        """ Read project version from branch create Conan reference
        """
        return os.getenv("CONAN_REFERENCE", "catch2/{}".format(self._version))

    @property
    def channel(self):
        """ Default Conan package channel when not stable
        """
        return os.getenv("CONAN_CHANNEL", "testing")

    @property
    def _version(self):
        """ Get version name from cmake file
        """
        pattern = re.compile(r"project\(Catch2 LANGUAGES CXX VERSION (\d+\.\d+\.\d+)\)")
        version = "latest"
        with open("CMakeLists.txt") as file:
            for line in file:
                result = pattern.search(line)
                if result:
                    version = result.group(1)
        return version

    @property
    def _branch(self):
        """ Get branch name from CI manager
        """
        printer = Printer(None)
        ci_manager = CIManager(printer)
        return ci_manager.get_branch()


if __name__ == "__main__":
    settings = BuilderSettings()
    builder = ConanMultiPackager(
        reference=settings.reference,
        channel=settings.channel,
        upload=settings.upload,
        upload_only_when_stable=False,
        stable_branch_pattern=settings.stable_branch_pattern,
        login_username=settings.login_username,
        username=settings.username,
        test_folder=os.path.join(".conan", "test_package"))
    builder.add()
    builder.run()

# Contributor Covenant Code of Conduct

## Our Pledge

In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.

## Our Standards

Examples of behavior that contributes to creating a positive environment include:

* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members

Examples of unacceptable behavior by participants include:

* The use of sexualized language or imagery and unwelcome sexual attention or advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a professional setting

## Our Responsibilities

Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.

Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.

## Scope

This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.

## Enforcement

Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at github@philnash.me. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.

Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.

## Attribution

This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]

[homepage]: http://contributor-covenant.org
[version]: http://contributor-covenant.org/version/1/4/

변형력(變形力) 또는 스트레스()은 역학에서 단위면적당 작용하는 힘을 뜻한다. 응력(應力)이라고도 한다. 오귀스탱 루이 코시가 1822년 처음 고안했다.

사실상 응력의 개념은 연속체(Continuum)라는 가정 아래 성립할 수 있다. 물체 내부의 경우, 가상의 단위부피를 설정해서 그 가상의 표면 바깥에 작용하는 힘을 계산하기 때문이다. 여기서 '가상의 힘'은 크게 두 종류가 있는데, 표면힘(Surface Force)과 몸체힘(Body Force)이다. 표면힘은 표면에 평행한 힘이며, 몸체힘은 표면에 대하여 수직 방향인 힘이다.

응력의 SI단위는 파스칼(Pa)이다. 압력과 같은 단위지만, 압력과 응력은 전혀 다른 개념이다.

일반적인 단면봉(Prismatic Bar)의 경우, 수직응력(Normal Stress)은 바깥쪽(Tension) 또는 안쪽(Compression)으로 작용한다. 변형률(Strain)과의 연관성 때문에, 보통 바깥쪽 응력을 양으로, 안쪽 응력을 음으로 본다. 이 경우, 보통은 계산의 편리성을 위해 모든 단면적에 고르게 힘이 작용한다라고 가정하고 평균값을 사용하는 경우가 많다. 즉,

실제로는 모든 지점마다 작용하는 응력의 값이 다르다. 때문에 코시는 이를 표현하기 위해 텐서를 사용했다.

이 방식은 축이 변할 경우 값이 어떻게 바뀌는지 계산하는 것이 힘들다는 단점을 가지고 있다. 이를 보완하기 위해 Mohr's Circle을 사용한다. 또한 코시 텐서는 작은 변형에 맞는 방식이기 때문에, 큰 변형의 경우 다른 방식을 사용한다.

응력 
응력(應力)은 물체가 외부 힘의 작용에 저항하여 원형을 지키려는 힘을 말하며 전단응력과 깊은 관계를 가지있으며 고체역학, 유체역학과도 연관있다. 한편 응력(凝力)은 원자, 분자 또는 이온 사이에 작용하여 고체나 액체 따위의 물체를 이루게 하는 서로 끌어당기는 힘을 통틀어 이르는 말로 응력(應力)과 연관있다.

같이 보기 

 연속체 역학

참고 

연속체역학
고전역학
텐서

ঢাকা বাংলাদেশের রাজধানী ও মহানগর বা বৃহত্তম শহর। প্রশাসনিকভাবে এটি ঢাকা বিভাগের ও জেলার প্রধান শহর। ভৌগোলিকভাবে এটি বাংলাদেশের মধ্যভাগে বুড়িগঙ্গা নদীর উত্তর তীরে একটি সমতল অঞ্চলে অবস্থিত। ঢাকা দক্ষিণ এশিয়ায় মুম্বাইয়ের পরে দ্বিতীয় বৃহৎ অর্থনৈতিক শহর। ঢাকার জিডিপি ১৬২ বিলিয়ন মার্কিন ডলার (২০২০)। এছাড়া ঢাকার পিপিপি ২৩৫ বিলিয়ন মার্কিন ডলার (২০২০)। ভৌগোলিকভাবে ঢাকা একটি অতিমহানগরী বা মেগাসিটি; ঢাকা মহানগরীর মোট জনসংখ্যা ৪ কোটি ৪২ লাখ ১৫ হাজার ১০৭ জন, যা দেশের মোট জনসংখ্যার প্রায় ১১ ভাগ। জনসংখ্যার বিচারে ঢাকা দক্ষিণ এশিয়ার দ্বিতীয় বৃহত্তম এবং বিশ্বের সপ্তম বৃহত্তম শহর। জনঘনত্বের বিচারে ঢাকা বিশ্বের সবচেয়ে ঘনবসতিপূর্ণ শহর; ৩০৬ বর্গকিলোমিটার আয়তনের এই শহরে প্রতি বর্গকিলোমিটার এলাকায় ২৩ হাজার লোক বাস করে।

ঢাকা শহর "মসজিদের শহর" নামেও সুপরিচিত। এখানে প্রায় দশ হাজারেরও বেশি মসজিদ আছে(ইসলামিক ফাউন্ডেশন বাংলাদেশ এর তথ্য মতে)। এই শহরে রোজ প্রায় ৫ লক্ষ রিকশা চলাচল করে। বর্তমানে ঢাকা দক্ষিণ এশিয়ার অন্যতম প্রধান সংস্কৃতি, শিক্ষা ও বাণিজ্যকেন্দ্র।

ঢাকা শহরের জলবায়ু ক্রান্তীয় আর্দ্র ও শুষ্ক প্রকৃতির। গড় তাপমাত্রা এপ্রিল মাসে সর্বোচ্চ প্রায় ৩৪ ডিগ্রী সেলসিয়াস এবং জানুয়ারি মাসে সর্বনিম্ন প্রায় ১৩ ডিগ্রি সেলসিয়াস। মে মাস থেকে সেপ্টেম্বর মাস পর্যন্ত এই অঞ্চলে বর্ষাকাল, সেসময় প্রতি মাসে গড়ে ৩০০ মিলিমিটারের বেশি বৃষ্টিপাত হয়।
 
সপ্তদশ শতাব্দীতে পুরান ঢাকা মুঘল সাম্রাজ্যের সুবা বাংলা (বাংলা প্রদেশ) এর প্রাদেশিক রাজধানী ছিল। মুঘল সম্রাট জাহাঙ্গীরের শাসনামলে এই শহর জাহাঙ্গীর নগর নামে পরিচিত ছিলো। বিশ্বব্যাপী মসলিন বাণিজ্যের একটি কেন্দ্র ছিলো ঢাকা এবং বিশ্বের বিভিন্ন স্থান থেকে ব্যবসায়ীগণ এখানে বাণিজ্যের উদ্দেশ্যে আসতেন। ঢাকাতে বিশ্বের সেরা মসলিন কাপড় উৎপাদিত হতো। যদিও আধুনিক ঢাকা শহরের বিকাশ ঘটে ঊনবিংশ শতাব্দীতে ব্রিটিশ শাসন আমলে, এই সময় নবাবগণ ঢাকা শাসন করতেন। এই সময় কলকাতার পরেই ঢাকা বাংলা প্রেসিডেন্সির দ্বিতীয় বৃহত্তম নগরী হয়ে ওঠে। ১৯০৫ সালের বঙ্গভঙ্গের পরে ঢাকা নবগঠিত পূর্ববঙ্গ ও আসাম প্রদেশের রাজধানী হয়। ১৯৪৭ সালে ভারত বিভাগের পরে ঢাকা পূর্ব পাকিস্তানের প্রশাসনিক রাজধানীতে পরিণত হয়। ১৯৫০-১৯৬০ সালের মধ্যে এই শহর বিভিন্ন সামাজিক, জাতীয়তাবাদী ও গণতন্ত্রপন্থী আন্দোলনের কেন্দ্রবিন্দু হয়ে ওঠে। ১৯৭১ সালে ঢাকা “স্বাধীন বাংলাদেশ রাষ্ট্রের রাজধানী” ঘোষিত হয়। ইতঃপূর্বে সামরিক আইন বলবৎ, বাংলাদেশের স্বাধীনতা ঘোষণা, সামরিক দমন, যুদ্ধ ও প্রাকৃতিক বিপর্যয়ের তাণ্ডবলীলার মতো একাধিক ঘটনার সাক্ষী হয় এই শহর।

বাংলাদেশের সংবিধানের ৫(ক) অনুচ্ছেদ অনুযায়ী ঢাকা বাংলাদেশের রাজধানী। আধুনিক ঢাকাকে বাংলাদেশের আপামর জনতা রাজনৈতিক, সাংস্কৃতিক ও অর্থনৈতিক জীবনের প্রধান কেন্দ্র  হিসেবে বিবেচনা করে। এটির প্রশংসিত জাতীয় দর্শনীয় স্থানগুলো যেমনঃ জাতীয় সংসদ ভবন, ঢাকা বিশ্ববিদ্যালয়, ঢাকা কলেজ,মুক্তিযুদ্ধ জাদুঘর, বাংলাদেশ জাতীয় জাদুঘর, লালবাগের কেল্লা, আহসান মঞ্জিল, হাতিরঝিল, জগন্নাথ বিশ্ববিদ্যালয়, জাহাঙ্গীরনগর বিশ্ববিদ্যালয়, জাতীয় স্মৃতিসৌধ, কেন্দ্রীয় শহীদ মিনার, বায়তুল মোকাররম মসজিদ, তারা মসজিদ, ঢাকেশ্বরী মন্দির, আর্মেনীয় গির্জা ইত্যাদি গুরুত্বপূর্ণ দর্শনীয় স্থান।

এই শহরের অবকাঠামো বিশ্বের মধ্যে উন্নত  হলেও দূষণ, যানজট এবং শহরমুখী মানুষের আধিক্যের কারণে জীবনমান উন্নয়নে ঋনাত্মক প্রভাব লক্ষ্যণীয়। সাম্প্রতিক দশকগুলিতে ঢাকার পরিবহন ও যোগাযোগ ব্যবস্থা, গণপূর্ত ব্যবস্থায় যে আধুনিকীকরণ হয়েছে, তা বিশেষভাবে লক্ষণীয়। বর্তমানে এই শহর প্রচুর বিদেশী বিনিয়োগ টানতে এবং ব্যবসা-বাণিজ্যের পরিধি বাড়াতে সক্ষম হয়েছে। সারা দেশ থেকে প্রচুর মানুষ ঢাকায় আসেন জীবন ও জীবিকার সন্ধানে। এ কারণে ঢাকা হয়ে উঠেছে বিশ্বের দ্রুততম ক্রমবর্ধমান নগরী, এই লক্ষ্য বাস্তবায়নে মালয়েশিয়া, জাপান, চীন, ভারত সহ বিভিন্ন দেশ অর্থ সহযোগিতা ও বিনিয়োগ করছে।

নামকরণের ইতিহাস 

ঢাকার নামকরণের সঠিক ইতিহাস নিয়ে ব্যাপক মতভেদ রয়েছে। কথিত আছে যে, সেন বংশের রাজা বল্লাল সেন বুড়িগঙ্গা নদীর তীরবর্তী এলাকায় ভ্রমণকালে সন্নিহিত জঙ্গলে হিন্দু দেবী দুর্গার একটি বিগ্রহ খুঁজে পান। দেবী দুর্গার প্রতি শ্রদ্ধাস্বরূপ রাজা বল্লাল সেন ঐ এলাকায় একটি মন্দির প্রতিষ্ঠা করেন। যেহেতু দেবীর বিগ্রহ ঢাকা বা গুপ্ত অবস্থায় খুঁজে পাওয়া গিয়েছিলো, তাই রাজা, মন্দিরের নাম রাখেন ঢাকেশ্বরী মন্দির। মন্দিরের নাম থেকেই কালক্রমে স্থানটির নাম ঢাকা হিসেবে গড়ে ওঠে।

আবার অনেক ঐতিহাসিকের মতে, মোঘল সম্রাট জাহাঙ্গীর যখন ঢাকাকে সুবাহ বাংলার রাজধানী হিসেবে ঘোষণা করেন; তখন সুবাদার ইসলাম খান আনন্দের বহিঃপ্রকাশস্বরূপ শহরে “ঢাক” বাজানোর নির্দেশ দেন। এই ঢাক বাজানোর কাহিনী লোকমুখে কিংবদন্তির রূপ নেয় এবং তা থেকেই শহরের নাম ঢাকা হয়ে যায়। এখানে উল্লেখ্য যে, মোঘল সাম্রাজ্যের বেশ কিছু সময় ঢাকা সম্রাট জাহাঙ্গীরের প্রতি সম্মান জানিয়ে জাহাঙ্গীরনগর নামে পরিচিত ছিলো।

ঢাকা নগরীকে বর্তমানে দু'ভাগে বিভক্ত করা হয়েছে - ঢাকা দক্ষিণ ও ঢাকা উত্তর। ঢাকা দক্ষিণই হলো পুরাতন মূল নগরী। ঢাকা উত্তর ঢাকার নবীন বর্ধিত উপশহরগুলো নিয়ে গঠিত।

ইতিহাস ও ঐতিহ্য 

ধারণা করা হয়, কালের পরিক্রমায় ঢাকা প্রথমে সমতট, পরে বঙ্গ ও গৌড় প্রভৃতি রাজ্যের অন্তর্ভুক্ত ছিলো। খ্রিষ্টীয় ১৩শ শতাব্দীর শেষের দিকে মুসলমানেরা ঢাকা দখল করে। মোঘল সম্রাট জাহাঙ্গীরের ফরমান অনুযায়ী ১৬ জুলাই ১৬১০ খ্রিষ্টাব্দে ঢাকাকে সুবাহ বাংলার রাজধানী ঘোষণা করা হয়। সম্রাট জাহাঙ্গীর-এর নাম অনুসারে রাজধানীর নাম জাহাঙ্গীরনগর রাখা হয়। সম্রাট জাহাঙ্গীরের জীবিতকাল পর্যন্ত এ নাম বজায় ছিলো।

এর আগে সম্রাট আকবরের আমলে বাংলা-বিহার-উড়িষ্যার প্রাদেশিক রাজধানী ছিলো বিহারের রাজমহল। সুবা বাংলায় তখন চলছিলো মোঘলবিরোধী স্বাধীন বারো ভূইঁয়াদের রাজত্ব। বারো ভূইয়ার নিয়ন্ত্রণ থেকে বাংলাকে করতলগত করতে ১৫৭৬ থেকে ১৬০৫ খ্রিষ্টাব্দ পর্যন্ত বারবার চেষ্টা চালানো হয়। এরপর সম্রাট জাহাঙ্গীরের শাসনামলে ১৬০৮ খ্রিষ্টাব্দে ইসলাম খান চিশতীকে রাজমহলের সুবেদার নিযুক্ত করেন। তিনি ১৬১০ খ্রিষ্টাব্দে বাংলার ভৌগোলিক অবস্থান বিবেচনা করে রাজধানী রাজমহল থেকে সরিয়ে ঢাকায় স্থানান্তর করেন।

সুবেদার ইসলাম খান চিশতী দায়িত্ব নেবার মাত্র পাঁচ বছরের মধ্যে বারো ভূঁইয়ার পতন ঘটে ও বর্তমান চট্টগ্রামের কিছু অংশ বাদে পুরো সুবে বাংলা মোগল সাম্রাজ্যের অধীনে চলে আসে।

১৬১০ খ্রিষ্টাব্দে ঢাকা সুবা বাংলার রাজধানী হলেও সুবাহ বাংলার রাজধানী বারবার পরিবর্তন করা হয়েছে। ১৬৫০ খ্রিষ্টাব্দে সুবেদার শাহ সুজা রাজধানী আবার রাজমহলে স্থানান্তর করেছিলেন। শাহ সুজার পতনের পর ১৬৬০ খ্রিষ্টাব্দে সুবেদার মীর জুমলা আবার রাজধানী ঢাকায় স্থানান্তর করেন। এরপর বেশ কিছুকাল ঢাকা নির্বিঘ্নে রাজধানীর মর্যাদা ভোগ করার পর ১৭১৭ খ্রিষ্টাব্দে সুবেদার মুর্শিদ কুলি খান রাজধানী মুর্শিদাবাদে স্থানান্তর করেন। এরপর ঢাকায় মোঘল শাসনামলে চলতো নায়েবে নাজিমদের শাসন, যা চলেছিল ১৭৯৩ সালে ব্রিটিশ শাসন শুরু হবার আগে পর্যন্ত। ব্রিটিশরা রাজধানী হিসেবে কলকাতাকে নির্বাচিত করলে ঢাকার গুরুত্ব আবারো কমতে থাকে।

এরপর দীর্ঘকাল পরে ১৯০৫ খ্রিষ্টাব্দে ঢাকা আবার তার গুরুত্ব ফিরে পায়। বঙ্গভঙ্গের পর ১৯০৫ সালে ঢাকাকে আসাম ও বাংলার রাজধানী করা হয়। কংগ্রেসের বাধার মুখে ব্রিটিশ রাজ আবার ১৯১১ সালে রাজধানী কলকাতায় ফিরিয়ে নেয়।

ভূগোল 

ঢাকা মধ্য বাংলাদেশে বুড়িগঙ্গা নদীর তীরে ২৩°৪২' থেকে ২৩°৫৪' উত্তর অক্ষাংশ এবং ৯০°২০' থেকে ৯০°২৮' পূর্ব দ্রাঘিমাংশ পর্যন্ত বিস্তৃত। নিম্ন গাঙ্গেয় সমভূমিতে অবস্থিত এই শহরের মোট আয়তন । ঢাকায় মোট ৪৬ টি থানা আছে। এগুলো হলো - চকবাজার, লালবাগ, কোতোয়ালি, সূত্রাপুর, হাজারীবাগ, রমনা, মতিঝিল, পল্টন, ধানমণ্ডি, মোহাম্মদপুর, তেজগাঁও, গুলশান, মিরপুর, পল্লবী, শাহ আলী, তুরাগ,খিলক্ষেত, সবুজবাগ, ঢাকা ক্যান্টনমেন্ট, ডেমরা, শ্যামপুর, বাড্ডা, কাফরুল, কামরাঙ্গীর চর, খিলগাঁও ও উত্তরা। ঢাকা শহরটি মোট ১৩০টি ওয়ার্ড ও ৭২৫টি মহল্লায় বিভক্ত। ঢাকা জেলার আয়তন ১৪৬৩.৬০ বর্গ কিলোমিটার (৫৬৫ বর্গমাইল)। এই জেলাটি গাজীপুর, টাঙ্গাইল, মুন্সীগঞ্জ, রাজবাড়ী, নারায়ণগঞ্জ ও মানিকগঞ্জ জেলা দ্বারা বেষ্টিত।

ক্রান্তীয় বৃক্ষ, আর্দ্র মৃত্তিকা ও সমুদ্রপৃষ্ঠের সঙ্গে সমান সমতলভূমি এই জেলার বৈশিষ্ট্য। এই কারণে বর্ষাকালে ও প্রাকৃতিক দুর্যোগের সময় ঢাকা জেলায় প্রায়শই বন্যা দেখা যায়।

আবহাওয়া ও জলবায়ু 
ঢাকার জলবায়ু প্রধানত উষ্ণ, বর্ষণমুখর এবং আর্দ্র গ্রীষ্মমন্ডলীয়। কোপেন জলবায়ু শ্রেণীবিভাগ এর অধীনে, ঢাকার জলবায়ু ক্রান্তীয় সাভানা জলবায়ু। এই শহরের একটি স্বতন্ত্র মৌসুম রয়েছে, এখানে বার্ষিক গড় তাপমাত্রা ২৭.৫ ডিগ্রি সেলসিয়াস(৮১.৫ ডিগ্রি ফারেনহাইট) এবং জানুয়ারি থেকে এপ্রিল মাসের মধ্যে তাপমাত্রা ১৯.৫ থেকে ৩২ ডিগ্রি সেলসিয়াসের(৬৭ থেকে ৯০ ডিগ্রি ফারেনহাইট) মধ্যে থাকে। মে থেকে অক্টোবর মাসের মধ্যে গড়ে প্রায় ২১২১ মিলিমিটার(৮৩.৫ ইঞ্চি) বৃষ্টিপাত হয়ে থাকে, যা সারাবছরের মোট বৃষ্টিপাতের প্রায় ৮৭%। যানজট এবং এবং শিল্প কারখানার অপরিকল্পিত বর্জ্য নির্গমনের ফলে প্রতিনিয়ত বায়ু এবং পানি দূষণ বাড়ছে, ফলে শহরের জনস্বাস্থ্য এবং জীবন মান মারাত্বকভাবে প্রভাবিত হচ্ছে। ঢাকার চারপাশে জলাশয় এবং জলাভূমি গুলি ধ্বংসের সম্মুখীন কারণ, এগুলো ভরাট হয়ে যাচ্ছে বহুতল ভবন এবং অন্যান্য আবাসন উন্নয়ন প্রকল্পের মাধ্যমে। দূষণের ফলে প্রকৃতির যে ক্ষতি হচ্ছে তার ফলে এই এলাকার জীববৈচিত্র্য হুমকির সম্মুখীন। যদিও বর্তমানে ঢাকাকে বসবাস উপযোগী করার বিভিন্ন পদক্ষেপ গ্রহণ করা হচ্ছে।

স্থানীয় সরকার 

ঢাকা পৌরসভা প্রতিষ্ঠিত হয়েছিল ১ আগস্ট, ১৮৬৪ সালে এবং পরবর্তীকালে ১৯৭৮ সালে এটি "কর্পোরেশন"-এ উন্নীত করা হয়। ঢাকা উত্তর সিটি কর্পোরেশন ও ঢাকা দক্ষিণ সিটি কর্পোরেশন নামের ২ টি স্ব-শাসিত সংস্থা ঢাকা শহরের পরিচালনের দায়িত্বে নিয়োজিত রয়েছে। এই শহর অনেকগুলি প্রশাসনিক ওয়ার্ডে বিভক্ত এবং প্রতিটি ওয়ার্ডে একজন কমিশনার দায়িত্বপ্রাপ্ত আছেন। প্রতি ৫ বছর পরপর সরাসরি ভোটের মাধ্যমে উভয় সিটি কর্পোরেশনে একজন করে মেয়র নির্বাচন করা হয়, যিনি প্রতিষ্ঠানের কার্যনির্বাহী প্রধান হিসাবে কাজ করেন। ওয়ার্ড কমিশনারও ৫ বছরের জন্য সরাসরি ভোটের মাধ্যমে নির্বাচিত হন। এছাড়াও মহিলাদের জন্য ঢাকা সিটি কর্পোরেশনে ৩০টি সংরক্ষিত কমিশনার পদ রয়েছে। ঢাকা শিক্ষা বোর্ড সকল সরকারি স্কুল এবং অধিকাংশ বেসরকারি স্কুলের প্রশাসনিক দায়িত্বে রয়েছে। তবে মাদ্রাসা এবং ইংরেজি মাধ্যমের স্কুলসমূহ এই বোর্ডের অন্তর্ভুক্ত নয়। বাংলাদেশের সকল মাদ্রাসা একটি কেন্দ্রীয় বোর্ডের মাধ্যমে এবং ইংরেজি মাধ্যমের স্কুল সমূহ একটি পৃথক শিক্ষাবোর্ড এবং প্রশাসনিক কাঠামোর অধিনে পরিচালিত হয়।

ঢাকা মেট্রোপলিটন পুলিশ (ডিএমপি) ১৯৭৬ সালে প্রতিষ্ঠিত হয়। মোট ১২টি পুলিশ স্টেশনে প্রায় ৬০০০ এরও বেশি পুলিশ সদস্য ছিলেন। শহরের জনসংখ্যা ব্যাপকভাবে বৃদ্ধি পাওয়ায় পুলিশবাহিনীতে সদস্য সংখ্যা ৩৪০০০ এ উন্নীত করা হয়, এবং এর কার্যক্রম পরিচালনা করা হয় ৫০টি পুলিশ স্টেশন রয়েছে।

ঢাকা শহর ২৫টি সংসদীয় এলাকায় বিভক্ত। এখানে প্রধান দুই রাজনৈতিক দল হল আওয়ামী লীগ এবং বাংলাদেশ জাতীয়তাবাদী দল। রমনায় সচিবালয় অবস্থিত এবং এখানেই সরকারের প্রায় সকল মন্ত্রণালয় রয়েছে। বাংলাদেশ সুপ্রীম কোর্ট এবং ঢাকা হাই কোর্ট এই শহরে অবস্থিত। বঙ্গভবন ভারতের গভর্নর-জেনারেল ও পূর্ব পাকিস্তান গভর্নর এর বাসভবন হিসেবে ব্যবহার হতো এবং বর্তমানে বাংলাদেশের রাষ্ট্রপতির বাসভবন হিসাবে ব্যবহৃত হচ্ছে। জাতীয় সংসদ ভবন বাংলাদেশ সরকারের এক কক্ষ বিশিষ্ট সংসদ কার্যক্রমের কাজে ব্যবহৃত হয়। খ্যাতনামা স্থপতি লুইস কান এই জাতীয় সংসদ ভবনের স্থপতি ছিলেন।বায়তুল মুকাররম এদেশের জাতীয় মসজিদ, মক্কার কাবা শরিফের নকশায় অনুপ্রাণিত হয়ে এই মসজিদের ডিজাইন করা হয়েছে। এই শহরের অন্যান্য ঐতিহাসিক স্থান সমূহের মধ্যে রয়েছে বড় কাটরা, লালবাগ কেল্লা, হোসেনী দালান, আহসান মঞ্জিল, বাহাদুর শাহ পার্ক, জগন্নাথ বিশ্ববিদ্যালয়, ইত্যাদি।

ঢাকায় একটি কেন্দ্রীয় পানি নিষ্কাশন ব্যবস্থা থাকলেও মোট জনসংখ্যার মাত্র ২৫% এই ব্যবস্থার আওতাভুক্ত, এর পাশাপাশি আরও ৩০% এই সুবিধা ব্যবহার করে সেপটিক ট্যাংকের মাধ্যমে। মাত্র দুই তৃতীয়াংশ লোক শহরে সরবরাহকৃত পানি ব্যবহার করতে পারে। এখানে প্রতি বছর ৯৭ লক্ষ টন কঠিন বর্জ্য উৎপন্ন হয়। সরকারি এবং বেসরকারি ব্যবস্থাপনার মাধ্যমে সফলতার সাথে এই বর্জ্য ব্যবস্থাপনার কাজ করা হয়ে থাকে। কেন্দ্রীয়ভাবে এই বর্জ্য ব্যবস্থাপনার জন্য বেশ কয়েকটি স্থান রয়েছে, তবে অনেক ক্ষেত্রেই এগুলো কাছাকাছি নিচু এলাকায় অথবা জলাশয়ে ফেলা হয়ে থাকে।

পৌর প্রশাসন 

ঢাকা পৌরসভা ১৮৬৪ সালের ১ই আগস্ট প্রতিষ্ঠিত হয়েছিল, এবং ১৯৭৮ সালে কর্পোরেশন অবস্থা উন্নীত হয়েছে। ঢাকা সিটি কর্পোরেশনের একটি স্বায়ত্ত কর্পোরেশন যা শহর বিষয়াবলি চালায় (অর্থাত ২০১১ সাল থেকে), ঢাকা সিটি করপোরেশন বর্তমানে দুই প্রশাসনিক অংশে বিভক্ত করা হয়েছে – এইগুলো হলো (১) ঢাকা উত্তর সিটি কর্পোরেশন এবং (২) ঢাকা দক্ষিণ সিটি কর্পোরেশন – ভাল নাগরিক সুবিধা নিশ্চিত করার জন্য। এই দুটি কর্পোরেশন প্রশাসকদের দ্বারা চালিত হয়। অন্তর্ভুক্ত এলাকায়গুলো কয়েকটি পৌরসভায় বিভক্ত করা হয়েছে, যা কমিশনার নির্বাচিত করেছেন। ঢাকা শিক্ষা বোর্ডের দায়িত্ব ও নির্দেশ অনুযায়ী সমস্ত সরকারি স্কুল এবং অধিকাংশ বেসরকারি স্কুলগুলো চালানো হয়, শুধুমাত্র ইংরেজি মাধ্যম স্কুলগুলো এবং মাদ্রাসাগুলো ছাড়া। বাংলাদেশে সকল মাদ্রাসা একটি কেন্দ্রীয় বোর্ড দ্বারা পরিচালিত যখন ইংরেজি মাধ্যম স্কুলগুলো পৃথক শিক্ষা ও শাসন কাঠামোর অধীনে হয়ে থাকে।

ঢাকা মেট্রোপলিটন পুলিশ ১৯৭৬ সালে প্রতিষ্ঠিত হয়। সেইসময় ৬,০০০ পুলিশ-বাহিনী মোট ১২টি পুলিশ থানায় কর্মরত ছিল। শহর দ্রুত বৃদ্ধির সঙ্গে সঙ্গে, বর্তমানে পুলিশ-বাহিনী উত্থাপিত হয়েছে প্রায় ৩৪০০০ জনে এবং ৫০টি পুলিশ থানা স্থাপনের কাজ সম্পন্ন হয়েছে।

ক্রমবর্ধমান যানজট এবং জনসংখ্যা সমস্যার মোকাবিলায় জাতীয় সরকার সম্প্রতি পার্শ্ববর্তী এলাকার দ্রুত নগরায়নের একটি নীতি বাস্তবায়ন করেছে। ঢাকা মহানগরীকে কেন্দ্র করে বিশেষত বর্তমানে দ্রুত জনবিস্ফোরণের যে পরিস্থিতি সৃষ্টি হয়েছে, তাতে আশঙ্কা করা হচ্ছে যে ২০৩৫ সালের মধ্যে নগরীর জনসংখ্যা ৩ কোটিকেও ছুঁয়ে ফেলতে পারে। ফলে স্বাভাবিক নাগরিক পরিষেবা ভেঙে পড়ার উপক্রম হবে। তাই ঢাকা শহরকে ঘিরে একদিকে বর্তমানে বিভিন্ন উপনগরীর প্রবর্তন করে ও অন্যদিকে সমগ্র দেশ জুড়েই দারিদ্রের যথাসাধ্য মোকাবিলা করে নগরমুখী লাগামছাড়া জনস্রোতকে কিছুটা মোকাবিলা করাই এই পরিকল্পনার লক্ষ্য।

প্রশাসনিক সংস্থা 

ঢাকা বিশ্বের অন্যান্য মেগা শহরগুলো থেকে ভিন্ন, ঢাকা বিভিন্ন মন্ত্রণালয়ের অধীনে চার বার সরকার প্রতিষ্ঠানের দ্বারা সেবা নিয়েছে। দুই কর্পোরেশন, উত্তর এবং দক্ষিণ, দুই ক্ষমতাহীন মেয়রদের নেতৃত্বে চালিত হয় যখন তাদের ওপর কোনো নিয়ন্ত্রণ ছিল না। তাছাড়া, তাদের মধ্যে সমন্বয়ের অভাব এবং বাংলাদেশ সরকার কর্তৃক সকল ক্ষমতার কেন্দ্রীভবন, একটি বিশৃঙ্খল পরিস্থিতি উন্নয়ন এবং তারা শহর রক্ষণাবেক্ষণ চালিয়ে যায়।

পানি ব্যবস্থাপনা
ঢাকায় একটি জলবাহিত নিকাশী ব্যবস্থা রয়েছে, কিন্তু ঢাকার জনসংখ্যার মাত্র ১৫% এই সেবা পায় এবং অপরদিকে ৩০% সেপটিক ট্যাংক সেবা পায়।

অর্থনীতি 

ঢাকা শহরের প্রকৃত নমিনাল জিডিপি ১৬২ বিলিয়ান মার্কিন ডলার এবং শহরের পিপিপি প্রায় ২৩৫ বিলিয়ন মার্কিন ডলার। ঢাকা বাংলাদেশের প্রধান বাণিজ্যিক কেন্দ্র। শহরে উঠতি মধ্যবিত্ত জনসংখ্যা বাড়ছে ঢাকা পাশাপাশি আধুনিক ভোক্তা এবং বিলাস পণ্যের বাজার বৃদ্ধি পাচ্ছে। ঐতিহাসিকভাবেই এই শহরে অভিবাসী শ্রমিকদের আকৃষ্ট করে আসছে। হকার, ছোটো দোকান, রিকশা, রাস্তার ধারের দোকান শহরের মোট জনসংখ্যার একটি বিরাট অংশ। শুধুমাত্র রিকশা চালকের সংখ্যাই ৫ লাখ এর বেশি। কর্মপ্রবাহের প্রায় অর্ধেকই গৃহস্থালি অথবা অপরিকল্পিত শ্রমজীবী হিসাবে কর্মরত আছেন। যদিও টেক্সটাইল শিল্পে প্রায় ৮০০,০০০ এরও বেশি মানুষ কাজ করছেন। তারপরও এখানে বেকারত্বের হার ছিলো প্রায় ১৯%। ২০১৯ সালের হিসাব অনুযায়ী ঢাকা শহরের স্থাবর সম্পদের মূল্য প্রায় ১৪২ বিলিয়ন ডলার। যার প্রবৃদ্ধি ৬.৪%। ঢাকার বার্ষিক মাথাপিছু আয় ১৩০০ মার্কিন ডলার এবং এখানে প্রায় ১৫% মানুষ দারিদ্র্য সীমার নিচে বসবাস করে। এই জনসংখ্যার একটি বড় অংশ কর্মসংস্থানের সন্ধানে গ্রাম থেকে শহরে এসেছে এবং এদের অনেকেরই দৈনিক আয় ৫ মার্কিন ডলারের কম।

শহরের প্রধান বাণিজ্যিক এলাকাগুলো হলো মতিঝিল, চকবাজার, নবাবপুর, নিউ মার্কেট, ফার্মগেট ইত্যাদি এবং প্রধান শিল্প এলাকা গুলো হল তেজগাঁও, হাজারীবাগ ও লালবাগ। বসুন্ধরা-বারিধারা একটি উন্নয়নশীল অর্থনৈতিক এলাকা এবং আগামী ৫ বছরের মধ্যে এই এলাকায় উচ্চ প্রযুক্তির শিল্পকারখানা, কর্পোরেশন এবং শপিং মল তৈরী করা হবে। ঢাকা রপ্তানি প্রক্রিয়াজাতকরণ অঞ্চল প্রধানত গার্মেন্টস, টেক্সটাইল এবং অন্যান্য পণ্য রপ্তানিতে উদ্বুদ্ধ করর লক্ষ্যে তৈরী করা হয়েছিল। ঢাকায় মোট দুটি ইপিজেড-এ মোট ৪১৩টি শিল্প স্থাপনা রয়েছে। এখানকার অধিকাংশ কর্মীই নারী। এই শহরের ঢাকা স্টক এক্সচেঞ্জ দেশের অন্যতম বৃহত স্টক এক্সচেঞ্জ, এখানে তালিকাভুক্ত বৃহত্তম আন্তর্জাতিক প্রতিষ্ঠানগুলোর মধ্যে রয়েছে সিটিগ্রুপ, এইচএসবিসি ব্যাঙ্ক বাংলাদেশ, জেপি মর্গান চেজ, স্ট্যান্ডার্ড চার্টার্ড ব্যাঙ্ক (বাংলাদেশ), আমেরিকান এক্সপ্রেস, শেভরন, এক্সন মবিল, টোটাল, ব্রিটিশ পেট্রোলিয়াম, ইউনিলিভার, নেসলে, ডিএইচএল, ফেডএক্স, ব্রিটিশ আমেরিকান টোবাকো ইত্যাদি। স্থানীয় বড় আকারের শিল্পগ্রুপ যেমন কনকর্ড গ্রুপ, র‌্যাংগস গ্রুপ, বেক্সিমকো গ্রুপ, টি কে শিল্প গ্রুপ, সামিট গ্রুপ, নাভানা গ্রুপ, জামান গ্রুপ অব ইন্ডাস্ট্রিজ, রহিম আফরোজ ইত্যাদি প্রতিষ্টানের প্রধান বাণিজ্যিক কার্যালয় ঢাকায় অবস্থিত। এই শহরেই নোবেল পুরস্কার প্রাপ্ত প্রতিষ্ঠান গ্রামীণ ব্যাংক, ব্র্যাক এবং বাংলাদেশের প্রথম ভূমি উন্নয়ন ব্যাংক প্রগতি কো-অপারেটিভ ল্যান্ড ডেভেলপমেন্ট ব্যাংক লিমিটেড (প্রগতি ব্যাংক) এর প্রধান কার্যালয় ঢাকা বিভাগেই অবস্থিত। নগরায়নের মাধ্যমে ব্যাপকভাবে শহরের উন্নয়ন চলছে, নতুন নতুন বহুতল ভবন তৈরী হচ্ছে ফলে খুব অল্প সময়ের মধ্যেই শহরের পরিবর্তন হয়েছে। ফাইন্যান্স, ব্যাংকিং, শিল্পোৎপাদন, টেলিযোগাযোগ এবং সেবা খাতে বিশেষভাবে উন্নয়ন হচ্ছে। পাশাপাশি শহরের অর্থনৈতিক উন্নয়নের জন্য পর্যটন এবং হোটেল রেস্তোরাঁর উন্নয়নও সমান গুরুত্বপূর্ণ।

পরিবহন 

 

ঢাকা বিশ্বের মধ্যে রিকশার রাজধানী নামে পরিচিত। প্রতিদিন গড়ে এখানে প্রায় ৪,০০,০০০ রিকশা চলাচল করে।

রিকশা এবং ইঞ্জিন চালিত অটো রিকশা ঢাকার অন্যতম প্রধান বাহন, আর এই শহরে যে প্রায় ৪০০০০০০ এর বেশি রিকশা চলাচল করে, তা অন্য সকল দেশের মধ্যে সর্বোচ্চ যদিও সরকারি হিসাব মতে ঢাকা শহরের জন্য মোট ৮৫,০০০ রিকশার নিবন্ধন দেয়া হয়েছে। রিকশা ঢাকা শহরের রাস্তার যানজটের অন্যতম কারণ এবং কিছু বড় বড় রাস্তায় রিকশা চলাচল বন্ধ করে দেওয়া হয়েছে।

সরকারি সংস্থা বাংলাদেশ সড়ক পরিবহন কর্পোরেশন পরিচালিত বাস ঢাকা শহরের পরিবহনের আরেকটি জনপ্রিয় উপায়। এছাড়া রয়েছে বহু বেসরকারি বাস সার্ভিস। ২০০২ খ্রিষ্টাব্দের পর থেকে ঢাকা শহরে পেট্রোল ও ডিজেলচালিত কিছু যানবাহন (বেবি ট্যাক্সি, টেম্পো ইত্যাদি) বন্ধ করে দেওয়া হয় ও পরিবর্তে প্রাকৃতিক গ্যাস (Compressed Natural Gas – CNG) বা সিএনজিচালিত সবুজ অটোরিক্সা চালু হয়। এর ফলে পরিবেশ দূষণ অনেক কমে এসেছে।

স্কুটার, ট্যাক্সি এবং ব্যক্তিগত মালিকানাধীন যানবাহনগুলো শহরের মধ্যবিত্ত শ্রেণীর মধ্যে খুব দ্রুত জনপ্রিয় হয়ে উঠছে সরকার দুই স্ট্রোক ইঞ্জিন বিশিষ্ট অটো রিকশার প্রতিস্থাপন করে "সবুজ অটোরিকশা" চালু করেছে যা সিএনজি অটোরিকশার বা বেবি-ট্যাক্সি নামে পরিচিত এগুলোতে পরিবেশ বান্ধব সংকুচিত প্রাকৃতিক গ্যাস ব্যবহার করা হয়। ঢাকা রাস্তা চলাচলকারী ট্যাক্সিগুলো দুই ধরনের হয়। হলুদ ট্যাক্সিগুলো কিছুটা উচ্চ মান সম্পন্ন হয়ে থাকে যদিও এটি ব্যয়বহুল। এই ট্যাক্সিগুলো শীতাতপ নিয়ন্ত্রিত; টয়োটা করোলা এর, টয়োটা প্রিমিও এর এবং টয়োটা এলিয়ন মডেলের গাড়িগুলো ট্যক্সি হিসাবে ব্যবহার করা হয় এখানে। ২০১৩ সালে এই সেবাটি প্রথমে ২০০-২৫০০ টি ট্যক্সি নিয়ে শুরু করা হয়েছিলো। সরকার ১,৫০০সিসি ক্ষমতা বিশিষ্ট ইঞ্জিনের আরও ৫,০০০ নতুন ট্যাক্সি আমদানি করার সিদ্ধান্ত নিয়েছে। সরকারের পক্ষ থেকে বলা হয়েছে এই ধরনের ট্যাক্সির সংখ্যা ১৮,০০০ পর্যন্ত বাড়ানো হবে।

, ঢাকার  রাস্তাগুলো বাঁধানো ছিলো। সড়কপথ, রেলপথের মাধ্যমে ঢাকা শহর দেশের অন্যন্য অংশের সাথে সংযুক্ত আছে। ঢাকা থেকে ভারতের কলকাতা ও আগরতলা ​​শহরে যাতায়াতের জন্য বিআরটিসি পরিচালিত নিয়মিত বাস সার্ভিস রয়েছে।

ঢাকার রেলওয়ে স্টেশনগুলোর মধ্যে রয়েছে কমলাপুর রেলওয়ে স্টেশন, বিমানবন্দর রেলওয়ে স্টেশনে, বনানী রেলওয়ে স্টেশনে, তেজগাঁও রেলওয়ে স্টেশন, ক্যান্টনমেন্ট রেলওয়ে স্টেশনে এবং গেন্ডারিয়া রেলওয়ে স্টেশন, রাষ্ট্র পরিচালিত বাংলাদেশ রেলওয়ে শহরতলি এবং জাতীয় রুটে সেবা প্রদান করে থাকে। বাংলাদেশ রেলওয়ের ঢাকা ও কলকাতার মধ্যে একটি নিয়মিত আন্তর্জাতিক ট্রেন সার্ভিস পরিচালনা করে থাকে। ঢাকা থেকে অন্যান্য শহরতলি এলাকায় রেল যোগাযোগ রয়েছে, নারায়ণগঞ্জ ও গাজীপুরে ডেমু (DEMU) ট্রেনের মাধ্যমে নিয়মিত রেলসেবা পরিচালনা করে আসছে বাংলাদেশ রেলওয়ে।

বুড়িগঙ্গা নদীর তীরে সদরঘাট নৌবন্দরের মাধ্যমে নদীর অপর পারে এবং বাংলাদেশের অন্যান্য বিভিন্ন স্থানে যাত্রী এবং মালপত্র পরিবহন করা হয়।

হযরত শাহজালাল আন্তর্জাতিক বিমানবন্দর, ঢাকা শহরের কেন্দ্রে থেকে মাত্র ১৫ কিলোমিটার উত্তরে অবস্থিত, এটি দেশের বৃহত্তম এবং ব্যস্ততম বিমানবন্দর। দেশের মোট বিমান আগমন এবং প্রস্থানের ৫২% পরিচালনা করা হয় এখানে। চট্টগ্রাম, সিলেট, রাজশাহী, কক্সবাজার, যশোর, বরিশাল, সৈয়দপুরে অভ্যন্তরীণ সেবা এবং এশিয়া, মধ্যপ্রাচ্য এবং পশ্চিম ইউরোপের প্রধান শহরগুলোতে আন্তর্জাতিক সেবাপরিচালনা করা হয়।

নাগরিক পরিষেবা 
ঢাকায় নাগরিক পরিষেবা প্রদানের জন্য বিভিন্ন সেবামূলক প্রতিষ্ঠান কাজ করে থাকে। ঢাকা শহরের পানি চাহিদা পূরণের জন্য ঢাকা ওয়াসা, বিদ্যুৎ সঞ্চালন লাইন বা বিদ্যুৎ সরবরাহ করার জন্য ডেসা এবং ডেসকো, গ্যাস সরবারহ করার জন্য তিতাস গ্যাস প্রভৃতি সেবামূলক সংস্থা নিয়োজিত রয়েছে।

জনগোষ্ঠী 

ঢাকা বাংলাদেশের সবচেয়ে বড় শহর যা বাঙালি সংস্কৃতির একটি ছবিও বলা চলে। ঢাকায় বসবাসকারীদের কিছু অংশের পূর্বপুরুষরা ভারতীয়। তারা অনেকেই ১৯৪৭ খ্রিষ্টাব্দে দেশ বিভাগের সময় ভারত থেকে এসেছিলেন। এদের মধ্যে কিছু বিহারী মুসলমানও ছিলেন। এদের সংখ্যা বর্তমানে কয়েক লক্ষ। এখানকার বেশিরভাগ লোক মুসলমান সম্প্রদায়ের, এদের সংখ্যা শতকরা ৮৫%। কিন্তু সাথে বহু হিন্দু সম্প্রদায়ের বাস এই শহরে যারা জনসংখ্যায় দ্বিতীয় অবস্থানে রয়েছে শতকরা ১০%। এছাড়াও  খ্রিস্টান, বৌদ্ধ এবং শিখ ধর্মাবলম্বী সম্প্রদায়ের লোক বসবাস করেন। ক্ষুদ্রনৃগোষ্ঠীর মাঝে হরিজন, ঋষি ও বাহাই সম্প্রদায়ের লোক বসবাস করে। ঢাকায় বসবাসকারী প্রায় সবাই বাংলা ভাষায় কথা বলেন, পুরান ঢাকা'র লোকেরা উর্দুতেও কথা বলে থাকেন। বর্তমানে নতুন প্রজন্মের অনেকেই ইংরেজি ভাষা ব্যবহার করে। ঢাকা নগরী অনেকগুলো ইংলিশ মিডিয়াম স্কুল আছে যারা ইংরেজি ভাষাকে শিক্ষার মাধ্যম হিসেবে ব্যবহার করে। কিছু ক্ষুদ্রনৃগোষ্ঠীরা হিন্দি, তামিল, তেলুগু ও ভোজপুরী ভাষাও ব্যবহার করে।

পুরান ঢাকার স্থানীয় আদি অধিবাসীদের 'ঢাকাইয়া' বলা হয়। তাদের আলাদা উপভাষা এবং সংস্কৃতি রয়েছে। ঢাকা রাজধানী হওয়ায় সারা বাংলাদেশ থেকেই এখানে লোকজন উন্নত জীবনযাপনের উদ্দেশ্যে আসে।

সংস্কৃতি 

ঢাকা বিশ্ববিদ্যালয় ও জগন্নাথ বিশ্ববিদ্যালয়, কে মূল ধরে তার পার্শ্ববর্তী এলাকা হচ্ছে ঢাকা শহরের সাংস্কৃতিক কেন্দ্র। ঢাকা বিশ্ববিদ্যালয়, জগন্নাথ বিশ্ববিদ্যালয় বাংলা একাডেমি, চারুকলা ইনস্টিটিউট, কেন্দ্রীয় গণ গ্রন্থাগার ও জাতীয় জাদুঘর এলাকা সংস্কৃতি-কর্মীদের চর্চা ও সাংস্কৃতিক প্রদর্শনীর মূল ক্ষেত্র। এর বাইরে বেইলি রোডকে নাটকপাড়া বলা হয় সেখানকার নাট্যমঞ্চগুলোর জন্য। এছাড়াও নবনির্মিত শিল্পকলা একাডেমির এক্সপেরিমেন্টাল থিয়েটার হল এবং অন্যান্য মঞ্চসমূহ নাট্য ও সঙ্গীত উৎসবে সব সময়ই সাংস্কৃতিক চর্চাকে অব্যাহত ধারায় এগিয়ে নিয়ে যাচ্ছে। কেন্দ্রীয় শহীদ মিনার এলাকায় বছরের বিভিন্ন সময়ে নাট্যোৎসব ও সাংস্কৃতিক উৎসব অনুষ্ঠিত হয়ে থাকে। একুশে ফেব্রুয়ারিকে কেন্দ্র করে প্রতি বছরের ফেব্রুয়ারি মাসের পুরোটা জুড়ে বাংলা একাডেমিতে একুশে বইমেলার আয়োজন করা হয়। বাংলা নববর্ষকে বরণ করতে পহেলা বৈশাখে রমনা পার্কে ছায়ানটের অনুষ্ঠানসহ সারাদিন গোটা অঞ্চলে সাংস্কৃতিক উৎসব চলে। সাংস্কৃতিক হৃদ্যতার ধারাবাহিকতায় আগারগাঁওয়ের মুক্তিযুদ্ধ জাদুঘরও সারা বছর ধরে বিভিন্ন অনুষ্ঠানমালার আয়োজন করে।

শিক্ষা ও শিক্ষা প্রতিষ্ঠান 

১৯০৫ খ্রিষ্টাব্দে বঙ্গভঙ্গের সময় হতেই ঢাকা এই প্রাদেশিক রাজধানীর শিক্ষার কেন্দ্র হয়ে ওঠে। এই সময়ই ১৯২১ খ্রিষ্টাব্দে ঢাকা বিশ্ববিদ্যালয় স্থাপিত হয়। ১৯৮০'র দশক পর্যন্ত ঢাকা বিশ্ববিদ্যালয়কে কেন্দ্র করে এর আশেপাশের এলাকাকে এডুকেশন ডিস্ট্রিক্ট বলা হতো। এই এডুকেশন ডিস্ট্রিক্টের অন্যান্য শিক্ষা প্রতিষ্ঠানগুলো হচ্ছে আইডিয়াল স্কুল এন্ড কলেজ,মতিঝিল মডেল স্কুল এন্ড কলেজ, গবর্নমেন্ট ল্যাবরেটরি হাই স্কুল,সরকারি বিজ্ঞান কলেজ, ভিকারুননেসা নুন স্কুল এন্ড কলেজ, উইলস্ লিটল ফ্লাওয়ার স্কুল এন্ড কলেজ, ঢাকা কলেজ,ঢাকা সিটি কলেজ,হলিক্রস কলেজ, নটর ডেম কলেজ, তেজগাঁও কলেজ (পূর্বে নাইট কলেজ), ইউনিভার্সিটি ল্যাবরেটরী স্কুল, ইডেন মহিলা কলেজ, ইষ্ট এন্ড হাই স্কুল, অগ্রণী বালিকা বিদ্যালয়, আজিমপুর গার্লস স্কুল, বেগম বদরুন্নেসা কলেজ, ঢাকা মেডিকেল কলেজ, ঢাকা ডেন্টাল কলেজ, ঢাকা আর্ট কলেজ (চারুকলা ইন্সটিটিউট) প্রভৃতি।

ঐতিহ্যগতভাবে ঢাকা বিশ্ববিদ্যালয়ের সুনাম সৃষ্টি হয়েছিলো ব্রিটিশ শাসনামলে। তখন একে প্রাচ্যের অক্সফোর্ড বলা হতো। বুদ্ধদেব বসুর মতো ছাত্র এবং বিজ্ঞানী সত্যেন বোসের মতো শিক্ষক তখন ঢাকা বিশ্ববিদ্যালয়ের সুনামকে উচ্চ শিখরে নিয়ে গিয়েছিলেন। বিশ্ববিদ্যালয়ের কার্জন হলটি সভ্যতার স্বাক্ষর বহন করে। চারুকলা ইনস্টিটিউটের উদ্যোগে পহেলা বৈশাখে আয়োজিত হয় বর্ণিল শোভাযাত্রা। অন্যদিকে পুরান ঢাকায় ১৮৫৮ সাল থেকে জগন্নাথ বিশ্ববিদ্যালয় কেন্দ্রিক সাংস্কৃতিক কেন্দ্র হিসেবে চলে আসছে।

বাংলাদেশের শিক্ষাব্যবস্থায় প্রধানত তিনটি মূল ধারা রয়েছে; এগুলোর প্রথমটি হচ্ছে সরকার নির্ধারিত পাঠক্রম (যা বাংলা অথবা ইংরেজি মিডিয়ামে পড়াশোনা করা যায়), দ্বিতীয়টি হচ্ছে বেসরকারি কেজি লেভেল হতে এ লেভেল পর্যন্ত ইংরেজি মিডিয়ামের ব্রিটিশ পাঠক্রম এবং তুতীয়টি হচ্ছে মূলত আরবি, ফার্সি ও উর্দু ভাষানির্ভর মাদ্রাসা শিক্ষাব্যবস্থা। মাদ্রাসাভিত্তিক এই শিক্ষা প্রতিষ্ঠানগুলোর কোনো কোনোটি সরকার নির্ধারিত পাঠক্রম এবং কোনো কোনোটি নিজস্ব পাঠক্রম ব্যবহার করে শিক্ষা প্রদান করে। শেষোক্ত এশ্রেণীর শিক্ষা প্রতিষ্ঠানগুলোর উপর সরকারের কোনো প্রশাসনিক নিয়ন্ত্রণ নেই। এই একই চিত্র ঢাকার শিক্ষা প্রতিষ্ঠানগুলোর ক্ষেত্রে প্রায় একশভাগ প্রযোজ্য।

বলা বাহুল্য নয় যে, এই শিক্ষা প্রতিষ্ঠানগুলোর অধিকাংশই ঢাকায় অবস্থিত। আশির দশক পর্যন্ত ঢাকাসহ বাংলাদেশে পাবলিক শিক্ষা প্রতিষ্ঠানই শিক্ষাক্ষেত্রে মূল চালিকাশক্তি ছিলো। এর পর হতেই বেসরকারি খাতে কিন্ডারগার্টেন ও স্কুলের প্রসার হতে শুরু করে। ১৯৯২ খ্রিষ্টাব্দে বেসরকারি বিশ্ববিদ্যালয় আইন ও ১৯৯৮ খ্রিষ্টাব্দে তার সংশোধন বেসরকারি বিশ্ববিদ্যালয় স্থাপনে এক বাঁধভাঙ্গা জোয়ার নিয়ে আসে। এযাবত প্রায় ৫৪টি বেসরকারি বিশ্ববিদ্যালয় স্থাপনের অনুমতি দিয়েছে সরকার। লক্ষণীয় বিষয় হলো এর মধ্যে প্রায় ৪৫টিই হলো ঢাকা বিভাগে।

ঢাকার সরকারি বিশ্ববিদ্যালয়সমূহ 

বাংলাদেশে বর্তমানে সর্বমোট ৫৩টির অধিক পাবলিক বা সরকারি বিশ্ববিদ্যালয়ের ১০টি হচ্ছে ঢাকা শহরে (তন্মধ্যে ২টি ক্যাম্পাস অস্থায়ী)। এগুলো হলো : 
 ঢাকা বিশ্ববিদ্যালয় (স্থাপিত : ১৯২১)
 বাংলাদেশ প্রকৌশল বিশ্ববিদ্যালয় (স্থাপিত : ১৯৬২)
 বঙ্গবন্ধু শেখ মুজিব মেডিকেল বিশ্ববিদ্যালয় (স্থাপিত : ১৯৯৮)
 শেরেবাংলা কৃষি বিশ্ববিদ্যালয় (স্থাপিত : ২০০১)
 জগন্নাথ বিশ্ববিদ্যালয় (স্থাপিত : ২০০৫)
 বাংলাদেশ ইউনিভার্সিটি অব প্রফেশনালস (স্থাপিত : ২০০৮)
 বাংলাদেশ টেক্সটাইল বিশ্ববিদ্যালয় (স্থাপিত : ২০১০)
 বঙ্গবন্ধু শেখ মুজিবুর রহমান মেরিটাইম বিশ্ববিদ্যালয় (অস্থায়ী ক্যাম্পাস) (স্থাপিত : ২০১৩)
 ইসলামি আরবি বিশ্ববিদ্যালয় (স্থাপিত : ২০১৪)
 বঙ্গবন্ধু শেখ মুজিবুর রহমান অ্যাভিয়েশন অ্যান্ড অ্যারোস্পেস বিশ্ববিদ্যালয় (স্থাপিত :২০১৯)

ব

# Unicode Support

```{currentmodule} click
```

Click has to take extra care to support Unicode text in different environments.

- The command line in Unix is traditionally bytes, not Unicode. While there are encoding hints, there are some
  situations where this can break. The most common one is SSH connections to machines with different locales.

  Misconfigured environments can cause a wide range of Unicode problems due to the lack of support for roundtripping
  surrogate escapes. This will not be fixed in Click itself!

- Standard input and output is opened in text mode by default. Click has to reopen the stream in binary mode in certain
  situations. Because there is no standard way to do this, it might not always work. Primarily this can become a problem
  when testing command-line applications.

  This is not supported:

  ```python
  sys.stdin = io.StringIO('Input here')
  sys.stdout = io.StringIO()
  ```

  Instead you need to do this:

  ```python
  input = 'Input here'
  in_stream = io.BytesIO(input.encode('utf-8'))
  sys.stdin = io.TextIOWrapper(in_stream, encoding='utf-8')
  out_stream = io.BytesIO()
  sys.stdout = io.TextIOWrapper(out_stream, encoding='utf-8')
  ```

  Remember in that case, you need to use `out_stream.getvalue()` and not `sys.stdout.getvalue()` if you want to access
  the buffer contents as the wrapper will not forward that method.

- `sys.stdin`, `sys.stdout` and `sys.stderr` are by default text-based. When Click needs a binary stream, it attempts to
  discover the underlying binary stream.

- `sys.argv` is always text. This means that the native type for input values to the types in Click is Unicode, not
  bytes.

  This causes problems if the terminal is incorrectly set and Python does not figure out the encoding. In that case, the
  Unicode string will contain error bytes encoded as surrogate escapes.

- When dealing with files, Click will always use the Unicode file system API by using the operating system's reported or
  guessed filesystem encoding. Surrogates are supported for filenames, so it should be possible to open files through
  the {func}`File` type even if the environment is misconfigured.

## Surrogate Handling

Click does all the Unicode handling in the standard library and is subject to its behavior. Unicode requires extra care.
The reason for this is that the encoding detection is done in the interpreter, and on Linux and certain other operating
systems, its encoding handling is problematic.

The biggest source of frustration is that Click scripts invoked by init systems, deployment tools, or cron jobs will
refuse to work unless a Unicode locale is exported.

If Click encounters such an environment it will prevent further execution to force you to set a locale. This is done
because Click cannot know about the state of the system once it's invoked and restore the values before Python's Unicode
handling kicked in.

If you see something like this error:

```console
Traceback (most recent call last):
  ...
RuntimeError: Click will abort further execution because Python was
  configured to use ASCII as encoding for the environment. Consult
  https://click.palletsprojects.com/unicode-support/ for mitigation
  steps.
```

You are dealing with an environment where Python thinks you are restricted to ASCII data. The solution to these problems
is different depending on which locale your computer is running in.

For instance, if you have a German Linux machine, you can fix the problem by exporting the locale to `de_DE.utf-8`:

```console
export LC_ALL=de_DE.utf-8
export LANG=de_DE.utf-8
```

If you are on a US machine, `en_US.utf-8` is the encoding of choice. On some newer Linux systems, you could also try
`C.UTF-8` as the locale:

```console
export LC_ALL=C.UTF-8
export LANG=C.UTF-8
```

On some systems it was reported that `UTF-8` has to be written as `UTF8` and vice versa. To see which locales are
supported you can invoke `locale -a`.

You need to export the values before you invoke your Python script.

In Python 3.7 and later you will no longer get a `RuntimeError` in many cases thanks to {pep}`538` and {pep}`540`, which
changed the default assumption in unconfigured environments. This doesn't change the general issue that your locale may
be misconfigured.

# Contributing

This is a quick reference for Click-specific development
tasks. For setting up the development environment and the
general contribution workflow, see the Pallets [quick
reference](https://palletsprojects.com/contributing/quick/)
and the [detailed contributing
guide](https://palletsprojects.com/contributing/).

## Extra Test Environments

Click includes some extra test environments:

-   `tox r -e stress` runs stress tests for race conditions
    in Click's test runner.

    ```shell-session
    $ tox r -e stress
    ```

-   `tox r -e random` runs tests in parallel in a random
    order to detect test pollution.

    ```shell-session
    $ tox r -e random
    ```

-   A CI workflow (`.github/workflows/test-flask.yaml`)
    runs Flask's test suite to catch downstream
    regressions.

## Code Style

Avoid ternary expressions (`x if cond else y`): coverage
cannot measure both branches. Use an explicit `if`/`else`
block instead.

Do not add unnecessary dependencies. If a feature can be
implemented with the standard library, do not pull in an
external package for it.

## Formatting

Wrap lines in Markdown files at 80 characters.

<a id="top"></a>
# Event Listeners

An event listener is a bit like a reporter, in that it responds to various
reporter events in Catch2, but it is not expected to write any output.
Instead, an event listener performs actions within the test process, such
as performing global initialization (e.g. of a C library), or cleaning out
in-memory logs if they are not needed (the test case passed).

Unlike reporters, each registered event listener is always active. Event
listeners are always notified before reporter(s).

To write your own event listener, you should derive from `Catch::EventListenerBase`,
as it provides empty stubs for all reporter events, allowing you to
only override events you care for. Afterwards you have to register it
with Catch2 using `CATCH_REGISTER_LISTENER` macro, so that Catch2 knows
about it and instantiates it before running tests.

Example event listener:
```cpp
#include <catch2/reporters/catch_reporter_event_listener.hpp>
#include <catch2/reporters/catch_reporter_registrars.hpp>

class testRunListener : public Catch::EventListenerBase {
public:
    using Catch::EventListenerBase::EventListenerBase;

    void testRunStarting(Catch::TestRunInfo const&) override {
        lib_foo_init();
    }
};

CATCH_REGISTER_LISTENER(testRunListener)
```

_Note that you should not use any assertion macros within a Listener!_

[You can find the list of events that the listeners can react to on its
own page](reporter-events.md#top).


---

[Home](Readme.md#top)

<a id="top"></a>
# Compile-time configuration

**Contents**<br>
[Prefixing Catch macros](#prefixing-catch-macros)<br>
[Terminal colour](#terminal-colour)<br>
[Console width](#console-width)<br>
[stdout](#stdout)<br>
[Fallback stringifier](#fallback-stringifier)<br>
[Default reporter](#default-reporter)<br>
[Bazel support](#bazel-support)<br>
[C++11 toggles](#c11-toggles)<br>
[C++17 toggles](#c17-toggles)<br>
[Other toggles](#other-toggles)<br>
[Enabling stringification](#enabling-stringification)<br>
[Disabling exceptions](#disabling-exceptions)<br>
[Disabling deprecation warnings](#disabling-deprecation-warnings)<br>
[Overriding Catch's debug break (`-b`)](#overriding-catchs-debug-break--b)<br>
[Static analysis support](#static-analysis-support)<br>
[Thread safety in assertions (and messages)](#thread-safety-in-assertions-and-messages)<br>

Catch2 is designed to "just work" as much as possible, and most of the
configuration options below are changed automatically during compilation,
according to the detected environment. However, this detection can also
be overridden by users, using macros documented below, and/or CMake options
with the same name.


## Prefixing Catch macros

    CATCH_CONFIG_PREFIX_ALL       // Prefix all macros with CATCH_
    CATCH_CONFIG_PREFIX_MESSAGES  // Prefix only message macros ((UNSCOPED_)INFO, WARN, (UNSCOPED_)CAPTURE)

To keep test code clean and uncluttered Catch uses short macro names (e.g. ```TEST_CASE``` and ```REQUIRE```). Occasionally these may conflict with identifiers from platform headers or the system under test. In this case the above identifier can be defined. This will cause all the Catch user macros to be prefixed with ```CATCH_``` (e.g. ```CATCH_TEST_CASE``` and ```CATCH_REQUIRE```).


## Terminal colour

    CATCH_CONFIG_COLOUR_WIN32     // Force enables compiling colouring impl based on Win32 console API
    CATCH_CONFIG_NO_COLOUR_WIN32  // Force disables ...

Yes, Catch2 uses the british spelling of colour.

Catch2 attempts to autodetect whether the Win32 console colouring API,
`SetConsoleTextAttribute`, is available, and if it is available it compiles
in a console colouring implementation that uses it.

This option can be used to override Catch2's autodetection and force the
compilation either ON or OFF.


## Console width

    CATCH_CONFIG_CONSOLE_WIDTH = x // where x is a number

Catch formats output intended for the console to fit within a fixed number of characters. This is especially important as indentation is used extensively and uncontrolled line wraps break this.
By default a console width of 80 is assumed but this can be controlled by defining the above identifier to be a different value.

## stdout

    CATCH_CONFIG_NOSTDOUT

To support platforms that do not provide `std::cout`, `std::cerr` and
`std::clog`, Catch does not use them directly, but rather calls
`Catch::cout`, `Catch::cerr` and `Catch::clog`. You can replace their
implementation by defining `CATCH_CONFIG_NOSTDOUT` and implementing
them yourself, their signatures are:

    std::ostream& cout();
    std::ostream& cerr();
    std::ostream& clog();

[You can see an example of replacing these functions here.](
../examples/231-Cfg-OutputStreams.cpp)


## Fallback stringifier

By default, when Catch's stringification machinery has to stringify
a type that does not specialize `StringMaker`, does not overload `operator<<`,
is not an enumeration and is not a range, it uses `"{?}"`. This can be
overridden by defining `CATCH_CONFIG_FALLBACK_STRINGIFIER` to name of a
function that should perform the stringification instead.

All types that do not provide `StringMaker` specialization or `operator<<`
overload will be sent to this function (this includes enums and ranges).
The provided function must return `std::string` and must accept any type,
e.g. via overloading.

_Note that if the provided function does not handle a type and this type
requires to be stringified, the compilation will fail._


## Default reporter

Catch's default reporter can be changed by defining macro
`CATCH_CONFIG_DEFAULT_REPORTER` to string literal naming the desired
default reporter.

This means that defining `CATCH_CONFIG_DEFAULT_REPORTER` to `"console"`
is equivalent with the out-of-the-box experience.


## Bazel support

Compiling Catch2 with `CATCH_CONFIG_BAZEL_SUPPORT` force-enables Catch2's
support for Bazel's environment variables (normally Catch2 looks for
`BAZEL_TEST=1` env var first).

This can be useful if you are using older versions of Bazel, that do not
yet have `BAZEL_TEST` env var support.

> `CATCH_CONFIG_BAZEL_SUPPORT` was [introduced](https://github.com/catchorg/Catch2/pull/2399) in Catch2 3.0.1.

> `CATCH_CONFIG_BAZEL_SUPPORT` was [deprecated](https://github.com/catchorg/Catch2/pull/2459) in Catch2 3.1.0.


## C++11 toggles

    CATCH_CONFIG_CPP11_TO_STRING // Use `std::to_string`

Because we support platforms whose standard library does not contain
`std::to_string`, it is possible to force Catch to use a workaround
based on `std::stringstream`. On platforms other than Android,
the default is to use `std::to_string`. On Android, the default is to
use the `stringstream` workaround. As always, it is possible to override
Catch's selection, by defining either `CATCH_CONFIG_CPP11_TO_STRING` or
`CATCH_CONFIG_NO_CPP11_TO_STRING`.


## C++17 toggles

    CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS  // Override std::uncaught_exceptions (instead of std::uncaught_exception) support detection
    CATCH_CONFIG_CPP17_STRING_VIEW          // Override std::string_view support detection (Catch provides a StringMaker specialization by default)
    CATCH_CONFIG_CPP17_VARIANT              // Override std::variant support detection (checked by CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER)
    CATCH_CONFIG_CPP17_OPTIONAL             // Override std::optional support detection (checked by CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER)
    CATCH_CONFIG_CPP17_BYTE                 // Override std::byte support detection (Catch provides a StringMaker specialization by default)

> `CATCH_CONFIG_CPP17_STRING_VIEW` was [introduced](https://github.com/catchorg/Catch2/issues/1376) in Catch2 2.4.1.

Catch contains basic compiler/standard detection and attempts to use
some C++17 features whenever appropriate. This automatic detection
can be manually overridden in both directions, that is, a feature
can be enabled by defining the macro in the table above, and disabled
by using `_NO_` in the macro, e.g. `CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS`.


## Other toggles

    CATCH_CONFIG_COUNTER                    // Use __COUNTER__ to generate unique names for test cases
    CATCH_CONFIG_WINDOWS_SEH                // Enable SEH handling on Windows
    CATCH_CONFIG_FAST_COMPILE               // Sacrifices some (rather minor) features for compilation speed
    CATCH_CONFIG_POSIX_SIGNALS              // Enable handling POSIX signals
    CATCH_CONFIG_WINDOWS_CRTDBG             // Enable leak checking using Windows's CRT Debug Heap
    CATCH_CONFIG_DISABLE_STRINGIFICATION    // Disable stringifying the original expression
    CATCH_CONFIG_DISABLE                    // Disables assertions and test case registration
    CATCH_CONFIG_WCHAR                      // Enables use of wchart_t
    CATCH_CONFIG_EXPERIMENTAL_REDIRECT      // Enables the new (experimental) way of capturing stdout/stderr
    CATCH_CONFIG_USE_ASYNC                  // Force parallel statistical processing of samples during benchmarking
    CATCH_CONFIG_ANDROID_LOGWRITE           // Use android's logging system for debug output
    CATCH_CONFIG_GLOBAL_NEXTAFTER           // Use nextafter{,f,l} instead of std::nextafter
    CATCH_CONFIG_GETENV                     // System has a working `getenv`
    CATCH_CONFIG_USE_BUILTIN_CONSTANT_P     // Use __builtin_constant_p to trigger warnings

> [`CATCH_CONFIG_ANDROID_LOGWRITE`](https://github.com/catchorg/Catch2/issues/1743) and [`CATCH_CONFIG_GLOBAL_NEXTAFTER`](https://github.com/catchorg/Catch2/pull/1739) were introduced in Catch2 2.10.0

> `CATCH_CONFIG_GETENV` was [introduced](https://github.com/catchorg/Catch2/pull/2562) in Catch2 3.2.0

> `CATCH_CONFIG_USE_BUILTIN_CONSTANT_P` was introduced in Catch2 3.8.0

Currently Catch enables `CATCH_CONFIG_WINDOWS_SEH` only when compiled with MSVC, because some versions of MinGW do not have the necessary Win32 API support.

`CATCH_CONFIG_POSIX_SIGNALS` is on by default, except when Catch is compiled under `Cygwin`, where it is disabled by default (but can be force-enabled by defining `CATCH_CONFIG_POSIX_SIGNALS`).

`CATCH_CONFIG_GETENV` is on by default, except when Catch2 is compiled for
platforms that lacks working `std::getenv` (currently Windows UWP and
Playstation).

`CATCH_CONFIG_WINDOWS_CRTDBG` is off by default. If enabled, Windows's
CRT is used to check for memory leaks, and displays them after the tests
finish running. This option only works when linking against the default
main, and must be defined for the whole library build.

`CATCH_CONFIG_WCHAR` is on by default, but can be disabled. Currently
it is only used in support for DJGPP cross-compiler.

With the exception of `CATCH_CONFIG_EXPERIMENTAL_REDIRECT`,
these toggles can be disabled by using `_NO_` form of the toggle,
e.g. `CATCH_CONFIG_NO_WINDOWS_SEH`.

`CATCH_CONFIG_USE_BUILTIN_CONSTANT_P` is ON by default for Clang and GCC
(but as far as possible, not for other compilers masquerading for these
two). However, it can cause bugs where the enclosed code is evaluated, even
though it should not be, e.g. in [#2925](https://github.com/catchorg/Catch2/issues/2925).


### `CATCH_CONFIG_FAST_COMPILE`
This compile-time flag speeds up compilation of assertion macros by ~20%,
by disabling the generation of assertion-local try-catch blocks for
non-exception family of assertion macros ({`REQUIRE`,`CHECK`}{``,`_FALSE`, `_THAT`}).
This disables translation of exceptions thrown under these assertions, but
should not lead to false negatives.

`CATCH_CONFIG_FAST_COMPILE` has to be either defined, or not defined,
in all translation units that are linked into single test binary.

### `CATCH_CONFIG_DISABLE_STRINGIFICATION`
This toggle enables a workaround for VS 2017 bug. For details see [known limitations](limitations.md#visual-studio-2017----raw-string-literal-in-assert-fails-to-compile).

### `CATCH_CONFIG_DISABLE`
This toggle removes most of Catch from given file. This means that `TEST_CASE`s are not registered and assertions are turned into no-ops. Useful for keeping tests within implementation files (ie for functions with internal linkage), instead of in external files.

This feature is considered experimental and might change at any point.

_Inspired by Doctest's `DOCTEST_CONFIG_DISABLE`_


## Enabling stringification

By default, Catch does not stringify some types from the standard library. This is done to avoid dragging in various standard library headers by default. However, Catch does contain these and can be configured to provide them, using these macros:

    CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER     // Provide StringMaker specialization for std::pair
    CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER    // Provide StringMaker specialization for std::tuple
    CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER  // Provide StringMaker specialization for std::variant, std::monostate (on C++17)
    CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER // Provide StringMaker specialization for std::optional (on C++17)
    CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS     // Defines all of the above

> `CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER` was [introduced](https://github.com/catchorg/Catch2/issues/1380) in Catch2 2.4.1.

> `CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER` was [introduced](https://github.com/catchorg/Catch2/issues/1510) in Catch2 2.6.0.

## Disabling exceptions

> Introduced in Catch2 2.4.0.

By default, Catch2 uses exceptions to signal errors and to abort tests
when an assertion from the `REQUIRE` family of assertions fails. We also
provide an experimental support for disabling exceptions. Catch2 should
automatically detect when it is compiled with exceptions disabled, but
it can be forced to compile without exceptions by defining

    CATCH_CONFIG_DISABLE_EXCEPTIONS

Note that when using Catch2 without exceptions, there are 2 major
limitations:

1) If there is an error that would normally be signalled by an exception,
the exception's message will instead be written to `Catch::cerr` and
`std::terminate` will be called.
2) If an assertion from the `REQUIRE` family of macros fails,
`std::terminate` will be called after the active reporter returns.


There is also a customization point for the exact behaviour of what
happens instead of exception being thrown. To use it, define

    CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER

and provide a definition for this function:

```cpp
namespace Catch {
    [[noreturn]]
    void throw_exception(std::exception const&);
}
```


## Disabling deprecation warnings

> Introduced in Catch2 3.9.0

Catch2 has started using the C++ macro `[[deprecated]]` to mark things
that are deprecated and should not be used any more. If you need to
temporarily disable these warnings, use

    CATCH_CONFIG_NO_DEPRECATION_ANNOTATIONS

Catch2 currently does not support more fine-grained deprecation warning
control, nor do we plan to.


## Overriding Catch's debug break (`-b`)

> [Introduced](https://github.com/catchorg/Catch2/pull/1846) in Catch2 2.11.2.

You can override Catch2's break-into-debugger code by defining the
`CATCH_BREAK_INTO_DEBUGGER()` macro. This can be used if e.g. Catch2 does
not know your platform, or your platform is misdetected.

The macro will be used as is, that is, `CATCH_BREAK_INTO_DEBUGGER();`
must compile and must break into debugger.


## Static analysis support

> Introduced in Catch2 3.4.0.

Some parts of Catch2, e.g. `SECTION`s, can be hard for static analysis
tools to reason about. Catch2 can change its internals to help static
analysis tools reason about the tests.

Catch2 automatically detects some static analysis tools (initial
implementation checks for clang-tidy and Coverity), but you can override
its detection (in either direction) via

```
CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT     // force enables static analysis help
CATCH_CONFIG_NO_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT  // force disables static analysis help
```

_As the name suggests, this is currently experimental, and thus we provide
no backwards compatibility guarantees._

**DO NOT ENABLE THIS FOR BUILDS YOU INTEND TO RUN.** The changed internals
are not meant to be runnable, only "scannable".



<a id="experimental-thread-safety"></a>
## Thread safety in assertions (and messages)

> Introduced in Catch2 3.9.0

> Made non-experimental in Catch2 3.12.0

Catch2 can optionally support thread-safe assertions, that means, multiple
user-spawned threads can use the assertion macros at the same time. Due
to the performance cost this imposes even on single-threaded usage, Catch2
defaults to non-thread-safe assertions.

    CATCH_CONFIG_THREAD_SAFE_ASSERTIONS     // enables thread safe assertions
    CATCH_CONFIG_NO_THREAD_SAFE_ASSERTIONS  // force-disables thread safe assertions

See [the documentation on thread safety in Catch2](thread-safety.md#top)
for details on which macros are safe and other notes.


---

[Home](Readme.md#top)

欧罗巴洲（），简称欧洲，是位于欧亚大陆西北部的一个洲，面积約，總人口達 748,571,960（截止2022年7月底），世界人口第三多的洲，僅次於亚洲和非洲，人口密度平均每平方公里70人，共有50個已獨立的主權國家。

欧洲东以烏拉山脈、烏拉河，东南以裏海、高加索山脉和黑海與亞洲為界，西、西北隔大西洋、格陵兰海、丹麦海峡与北美洲相望，北接北極海，南隔地中海与非洲相望。

歐陸最北端是挪威的北角，最南端是西班牙的马罗基角，欧洲是世界上第二小的洲、大陆，僅比大洋洲大一些，其與亞洲合稱為欧亚大陆，而與亞洲、非洲合稱為歐亞非大陸。

歐洲嚴格來說在地質學上也不算是一個洲，只能算是為了地緣政治和文化而劃分的洲。歐洲並不是由海洋或其他自然邊界完全或幾乎完全與其他陸地隔離的相連的陸地。通常，根据政治、经济、文化或实际考虑，欧洲的边界线并不总是一样的。这就使得人们产生了几个不同“欧洲”的观念。

名称 

在古希腊神话中，欧罗巴（）是一位腓尼基公主，她受到变成公牛的宙斯的引诱。一种说法认为她的名称来自古希腊语语素“”（；）与“”（；属格：，；），因此其复合形式“”（）可能有“宽广的视野”或“辽阔的方位”之意。

世界上大多数语言使用“” 或“Europa”的音译词指代该大陆。在中文中，“欧洲”是“欧罗巴洲”一词的缩写，后者是由利玛窦于自己翻译的《坤舆万国全图》中率先使用的。尽管在日语中片假名“”（）正逐渐常用，在欧洲联盟的“”（）等词汇中也保留了来自漢字的“”（）用法。在一些突厥语系语言中，除了“”或“”，原先的波斯语名称“”（法蘭吉斯坦；）也会用来指代欧洲的大部分地区。

定义 

可点击欧洲地图：显示与亚洲大陆因历史原因形成的边界线。（参见亚洲与欧洲的分界线获得更多信息）。

图例：蓝 = 洲际国家；绿 = 有时会被认为是欧洲，但在欧洲边界线之外。

地理

地形 

歐洲的地形樣貌頗為豐富。

東歐是一望無際的大草原地形，歐洲東南界為高加索山脈，其主峰厄爾布魯士峰海拔5642米，是歐洲最高峰。其餘歐洲地區除法國、荷蘭、比利時等沿海地區有大片的平原外，其餘多為山地丘陵、平原和高地交錯分佈的地形，阿爾卑斯山山脈橫亙歐洲中部，法國與西班牙、安道爾以庇里牛斯山山脈為界，北歐則多冰河地形，有許多冰河切割消溶入海後所造成的峽灣地形，冰島則除了冰河地形以外有很多火山地形。

水文 

歐洲流經數國的大河有萊茵河、多瑙河、易北河、奥得河等。此外主要河流還有法國境內的塞納河、卢瓦尔河、加隆河等、俄國境內的伏尔加河、第聶伯河、烏拉爾河、英国境内的泰晤士河、意大利境内的波河等。

除了河流，歐洲有許多湖泊。其中冰河所遺留下的冰蚀湖使芬蘭被稱為千湖之國。

氣候 
歐洲緯度是在北緯35度以北，大部分屬溫帶氣候，並向北延伸至北極圈，故北歐西部及南部屬温帶氣候。整个欧洲不存在最热月平均气温高于30摄氏度的酷暑区，亦不存在最冷月平均气温低于零下20摄氏度的酷寒区，灾害性天气亦较其他各洲少。

在西風的吹拂及洋流的調節之下，西歐及北欧西部沿海的氣候是全球正偏差最大的區域，因沿海有北大西洋暖流流經，故此冬无严寒，夏无酷暑，宜人居住，多屬於溫帶海洋性氣候。

東歐則屬温带大陸性湿润氣候，年溫差较西欧大，但仍较同纬度的东亚大陆小。南歐緊鄰地中海，夏乾冬雨，因為夏天副熱帶高壓壟罩，冬天西風吹拂。而北冰洋沿岸地区属苔原气候。

历史

远古历史 

根据这两、三百年的考古发掘，证实欧洲（包括英国等地）在舊石器时代已经有人類活动。

公元前4000年－前26世紀，西欧的凯尔特人就出现巨石文化，现在还留有欧洲巨石建筑遗迹。地中海东部的爱琴海被认为是欧洲文明的发祥地。

公元前2000年左右，古希腊人的祖先就定居在爱琴海的克里特岛，它也成为古希腊文明的发源地，并且逐渐發展出城邦文化。

公元前5世纪，伯罗奔尼撒战争过后，古希腊本土逐渐走向衰落，但是其文化影响力继续扩大，

公元前3世纪，希腊边境馬其頓王国的亞歷山大大帝征服埃及和波斯，建立橫跨歐亞非三洲的大帝國，将希腊文化传播到亞洲和非洲地区，史称希腊化时代，给人类留下丰富的文化遗产。

公元前27年，古罗马兴起，成立羅馬帝国，成为一个统治欧洲、西亚和北非的大帝国，地中海成为其内海。亚平宁半岛是當時歐洲政治和经济的中心地区。

公元1世纪后，基督教逐渐在罗马境内传播开来。

313年，基督教被定为罗马国教，取得在欧洲的统治地位。
3世纪後期，罗马帝国逐渐衰弱。
376年，匈人擊敗東哥德王國，哥德人被迫渡過多瑙河進入西羅馬帝國。
395年，分裂成为東、西两個帝国。北欧的日尔曼人及东欧的斯拉夫人相继兴起。

4世紀，來自東方的匈人迫使東歐各族不斷向西遷移。
436年，西哥德人滅亡西羅馬帝國，西歐進入中世纪。
帝國的東半部（東羅馬帝國）則持續發展至1453年，最後被鄂圖曼土耳其人所滅。

中古史 

中世纪时期，许多民族相繼建立王國，採行封建采邑制，战争不断，基督教教會遂逐漸成為社會上安定人心、救濟民眾的重要機構。修士的虔誠服務、默默行善及清高廉潔的形象，對傳布基督信仰助益甚多。

8世紀，查理曼建立查理曼帝國。
843年，即分裂。该帝国的東半部发展成为神圣罗马帝国。英国、法国、德国、意大利等许多国家的雛型都是在这一时期形成建立起来的。

天主教教會在西歐握有極大力量，所有知識傳承都在修道院中進行。宗教迫害和十字军东征给欧洲人民带来很大的灾难，这一时期被啟蒙時代的學者稱為黑暗時代。在这段时间内，欧洲，尤其是南欧和东欧遭受亚洲游牧民族的多次入侵，比如阿拉伯人、马扎尔人、阿瓦尔人、蒙古人和土耳其人。

近代史 
14世纪开始，在西欧和南欧的一些国家中，特别是英國、法國、葡萄牙、西班牙，资本主义开始萌芽，通过地理大发现和对海外的冒險，足跡遍及非洲、美洲和亚洲。

同一時期歐洲開始發生文化的大量精進，被稱為文藝復興，這也引發了宗教革命，許多國家脫離天主教教會的管轄而改奉新教，政教合一的各國常因教派不同而引發政爭，甚至有許多的宗教戰爭。在西歐的政教紛擾之際，東方信奉東正教的俄羅斯則在彼得大帝及隨後的幾位沙皇領導下逐漸強盛。

16世纪，原来统治德意志、西班牙、葡萄牙及其殖民地的哈布斯堡王朝衰落，最终在三十年战争中丧失了欧洲霸主的地位。

1667年到1763年，是新興的英国、法国、荷蘭三強鼎立，一共爆发六次战争：法国与西班牙——荷兰的遗产战争（1667年～1668年）、法国与荷兰的法荷战争（1672年～1678年）、反法同盟与法国的大同盟战争（1688年～1697年）、西班牙王位继承战争（1700年～1713年）、英国——奥地利与法国——普鲁士的奥地利王位继承战争（1740年～1748年）和英国——普鲁士与法国——奥地利——俄国的七年战争（1756年～1763年）。

这些战争的最后结果：英国击败法国和荷兰，夺取大片海外殖民地，建立了“日不落帝国”；法国的君主专制制度崩溃，最终爆发震撼世界的法国大革命。

17世纪末，英國政治上發生光榮革命。18世纪，英國開始工业革命，隨即影響歐洲大陸，也促進了民族國家的興起。

義大利、德國在19世紀完成統一，隨著科技的進步、對外界的不斷探索及進化論的提出，歐洲成為帝國主義的搖籃，掠奪全世界的資源。

20世纪初，帝國主義的極度擴張終於導致欧洲变为战争策源地，发生兩次世界大戰，使欧洲遭受很大的创伤并喪失世界霸權。歐洲國家陸續喪失其殖民地統治權。

第一次世界大戰期间，出现世界上第一个社会主义国家——苏联。二战后，在苏联的影响下，又出现一批社会主义国家。

1950年代开始，出现以美國为首的北大西洋公约组织成员国及以蘇聯为首的华沙条约组织缔约国兩個集團對峙的局面。

欧洲被划分为两个主要的政治经济阵营：东欧的共产主义和西欧的资本主义。

到1990年，随着苏联解体，冷战结束，欧洲的政治格局发生重大变化。东欧的社會主義國家重新回歸資本主義。

现在，“欧洲”这个词被更广泛的用来作为欧洲聯盟的代名词。现在欧盟有29个成员国，更多的一些成员身份谈判正在或即将进行。所有欧盟成员国都是歐洲委員會的成员国。

地區 

 欧洲可分为西欧、中欧、东欧、北欧和南欧、亞欧交界國地区：

（須注意的是，此分區方法並非唯一，根據地理、政治、文化等考量，可能會有不同的分區方式）

其他地区和有限承认的国家

聯合國的分區方法

政治 

歐洲是近代西方政治思想的主要發源地。在政治制度方面，無論是民主制、共和制、君主立憲制（內閣制）、雙首長制等均源自於歐洲，世界各國普受影響。

在政治色彩上，歐洲政治思潮從左到右，一列俱全，諸如無政府主義、納粹主義、法西斯主義、保守主義、君主主義、乃至社會主義、共產主義，均在歐洲政治史上扮演一定角色，此較諸其他各大洲，是為歐洲獨特之處。現在歐洲某些國家左派與右派輪流執政，形成鐘擺效應也為頗值關注。

欧洲一体化越来越成为欧洲发展的趋势。欧洲许多国家的政党之间组成各自的联盟，例如歐洲人民黨、欧洲绿党、欧洲自由民主改革党、歐洲左派黨、歐洲民主黨、歐洲自由聯盟等。除美國以外，北大西洋公約組織的會員國主要是由歐洲各國所組成。目前歐洲在聯合國共有44個會員國，其中英、法、俄是聯合國安理會的常任理事國。

现在的欧洲是世界最为关注的战略重点，欧盟的发展加强欧洲一体化，現時欧盟更為一個超國家組織，是影响世界经济政治发展的重要因素。在冷战结束后，美欧争夺欧洲主导权的斗争开始浮现出来。

欧洲对于同性恋人士的政策在世界上也是最为宽容的。在全球二十多个承认同性婚姻的国家中，欧洲就有十六个，分別是荷兰、比利时、西班牙、挪威、瑞典、葡萄牙、冰岛、丹麦、法国、卢森堡、爱尔兰、芬兰、英国、马耳他、德國及奥地利。另外欧洲还有十多个国家承认同性伴侣民事结合，他们是安道尔、捷克、斯洛文尼亚、瑞士、匈牙利、列支敦士登、克罗地亚、塞浦路斯、爱沙尼亚、希腊、意大利、圣马力诺。欧洲有37个国家立法禁止在就业、医疗等社会日常生活中基于对性倾向的歧视行为。此外，欧洲所有的国家规定两个成年人之间自愿的同性恋行为合法。

经济 

资本主义最早从欧洲发展起来，其工业和农业的机械化水平也是各洲中最高的。欧洲绝大多数国家都属发达国家，其中以北欧、西欧和中欧一些国家经济发展水平最高。

随着欧盟的发展，欧洲经济一体化程度越来越高，1979年3月13日开始在欧洲共同体内部使用欧洲货币单位作为计价结算的一种货币单位。现在歐元（€ ISO 4217碼EUR）是目前歐盟28個會員國中的18國（也有這18國以外的國家，已經是31個國家和地區的官方貨幣）所使用的貨幣。歐盟各國對於是否加入歐元區皆有自身利益的考量，目前有一半以上的歐盟會員國仍發行自己國家的货幣，並未加入歐元區的行列，例如：丹麦克朗等。歐元區是目前世界主要經濟體之一，歐元區經濟的榮枯深深地影響著全世界的景氣。

在欧洲一些传统产业中，农业的现代化水平很高。全洲耕地总面积约2.9亿公顷，农业人口比重为15％。但是由于人口稠密，消费高，大多数国家粮食不能自给。欧洲的工业产值是各洲中最高的，交通运输业極其发达，全洲有35万千米铁路；公路总长420万千米；海运总吨位约占世界的45％，具有很强的外贸经济的特点。此外，欧洲航空业和旅游业也很发达。

人口 

歐洲的人口約有7.28億人(2005年數據)，約占世界總人口的11%。其平均人口密度居各大洲的第一位。目前歐洲各國多面臨生育率下降及人口老化的問題，而推行各種政策以使人口正常成長。

來源：UNPP

民族及語言 

欧洲各民族主要是属于印欧语系语言的民族（超过90%的欧洲居民），最为广泛使用的有波罗的语族、罗曼语族、日尔曼语族、斯拉夫语族、凯尔特语族以及阿尔巴尼亚语、希腊语，也有从东方迁徙过去的使用乌拉尔语系语言的各民族和古老的巴斯克民族，在俄罗斯的欧洲部分尚有一部分使用阿尔泰语系的民族。基本是以民族国家划分，有的生活在不同国家的操同一语言的人群承认属于同一民族，但有的不愿意承认，只强调自己是那一国家的人。

欧洲人分屬多個不同的語族，其中有：
 印欧语系
 波罗的语族：拉脱维亚语、立陶宛语
 罗曼语族：法语、加泰罗尼亚语、加里西亞語、罗马尼亚语、罗曼什语、葡萄牙语、西班牙语、意大利语
 日尔曼语族：冰岛语、丹麦语、德语、荷兰语、卢森堡语、挪威语、瑞典语、英语
 斯拉夫语族：白俄罗斯语、波兰语、波斯尼亚语、俄语、捷克语、克罗地亚语、马其顿语、塞尔维亚语、斯洛伐克语、斯洛文尼亚语、乌克兰语
 凯尔特语族：爱尔兰语、苏格兰语、威尔士语
 阿尔巴尼亚语
 希腊语
 印度－伊朗语族：羅姆語
 乌拉尔语系：
 芬兰-乌戈尔语族：爱沙尼亚语、芬兰语、匈牙利语
 阿爾泰语系：
 突厥語族：土耳其語、韃靼語、楚瓦什語、哈萨克语
 蒙古語族：卡爾梅克語
 亞非語系：馬爾他語、阿拉伯語、希伯來語
 孤立語言
 巴斯克語

關於歐盟成員國的語言使用，參見歐洲聯盟的語言。

教育与文化 

所有欧洲国家的公民都要接受义务教育，或者至少是接受某种教育培训。欧洲的义务教育大概从6、7岁开始，一直持续到15、16岁。在大多数欧洲国家，基础教育的时间大概只持续四到五年，而在少数国家，却需要七八年。基础教育完成之后，学生所继续接受教育的高一级的学校就有多种类型了，有继续为高等学校预先培养人才的文理中学，还有一些技工学校。与此同时，在许多国家还有许多很有名望的高等专科学校和综合性大学，接纳那些已经完成初中等教育的学生。在这种教育体制的促进下，几乎所有欧洲国家的文盲率都很低。

雕刻艺术建筑、美术、文学以及音乐都是在欧洲具有悠久历史的傳統事物。许多城市，比如倫敦、巴黎、维也纳、罗马、柏林以及莫斯科等，今天都是在作为首都的同时，也被视作该国的文化中心。此外，在许多城市还有很多重要的剧院、博物馆、交响乐团以及其他很重要的文化设施。

古代文化 
欧洲具有很深厚的文化底蕴。欧洲史前美术体现了欧洲旧石器时代、中石器时代和新石器时代的建筑、雕刻、绘画和工艺的成就，其中欧洲旧石器时代艺术是迄今所知人类最早的真正的艺术品。此外欧洲史前器具艺术具有很强的表现力，被学者们称之为活动艺术。

11～17世纪，欧洲中世纪大学的兴起奠定了现代高等教育的模式。

科学文化的交流与合作 
欧洲各国在科学、文化等方面的合作也很紧密。

在文化方面，1950年创立以西欧和地中海沿岸国家广播电视机构为主的欧洲广播联盟。1957年8月21日创立的欧洲新闻社联盟增进各国新闻社之间的交流与合作。

在科学技术方面，由法国、德国、比利时、瑞典、荷兰、丹麦、意大利、瑞士8个国家共同经营的欧洲南天天文台是位于南半球的大型综合性天文台，其研究课题几乎涉及天文学的各个领域。1973年由30多个国家建立的欧洲分子生物学实验室促进欧洲各国在分子生物学领域的迅速发展。1975年5月30日由欧洲多个国家组成的-{zh-hans:欧洲空间局; zh-hant:歐洲太空總署;}-在航天领域很有竞争力。

宗教 

欧洲的宗教中，72%主要是信仰基督宗教（包括天主教、基督新教以及东正教）。

8％是伊斯兰教，其中大多数在俄罗斯生活（两千五百万），除此之外，在土耳其（590万）、法国（550万）、德国（320万）、波斯尼亞和黑塞哥維那與阿尔巴尼亚（140－250万）以及意大利（110万）等欧洲广大地区都有穆斯林分布，西欧的穆斯林主要为移民。

仅有少于1％的欧洲居民信仰犹太教（将近200万人）。其他的宗教（如印度教、佛教等）也都仅有低于1％的信徒。

部分欧洲国家无宗教人口的比例相对较高。根据欧洲联盟2005年公布的调查结果，无宗教信仰人口比例，超过60%的有英国、法国、荷兰、瑞典等国，超过50%的有德国、比利时、瑞士、挪威等国，而低于10%的有罗马尼亚、土耳其等国，低于20%的有葡萄牙、希腊、波兰等国。

國際關係

歐洲與亞太 
歐洲部分國家在亞太各地曾建立廣大的殖民地，例如：英國擁有印度、新加坡、馬來西亞、緬甸和香港等；法國擁有印度支那，即今日中南半島東部地區；葡萄牙曾管治澳門、果阿邦和東帝汶；西班牙曾管治菲律賓；荷蘭曾擁有東印度群島，亦即今日的印尼。也因此東南亞國家與歐洲國家的關係非常深厚，由於這般深厚的關係，今日國際關係中，歐洲對於東南亞仍有一定程度的影響力；在曾受西班牙統治，以天主教為國教的菲律賓，教宗所指派的樞機主教亦有政治及社會上的影響力。東北亞的日本曾與德國、義大利在第二次世界大戰中組成軸心國，現在日本、韓國與歐洲各國主要是以經濟關係為主，政治上的結盟已漸次減少。

歐洲與中亞 
從17世紀開始到20世紀，中亞大部分地區成了俄羅斯帝國以及隨後的蘇聯的領土，大量東歐的斯拉夫人開始遷移到哈薩克斯坦和吉爾吉斯斯坦。蘇聯解體後，哈薩克斯坦和吉爾吉斯斯坦的斯拉夫人開始大規模遷移回俄羅斯，導致哈薩克斯坦和吉爾吉斯斯坦的俄羅斯族人口比例大大下滑。蘇聯對中亞地區的統治，帶來了工業化和大量基礎設施的建設，但也伴隨著對地方文化的壓制，集體化項目的失敗導致很多人死亡，長期以來，該地區的民族關係都很緊張，也出現了一些環境問題。

歐洲與中東（西亞） 
地理上，歐洲與中東（西亞）是近鄰，歷史上，歐洲與中東的關係一向緊張，基本上是由於兩者在宗教理念上的根本不同：歐洲大部份國家以基督宗教為主要信仰，而伊朗和阿拉伯國家多以伊斯蘭教為國教。中東多個地區曾經在20世紀初第一次世界大戰之後成為英國和法國的殖民地。

橫跨歐洲與小亞細亞的伊斯蘭教國家土耳其本身與傳統歐洲各國的關係就非常微妙，它地處亞歐交界處，且它曾經既滅亡拜占庭帝國，現在又極渴望加入歐盟。

歐美 
歐洲與美國雖然在文化、民風等各方面，有著濃厚的歷史淵源和聯繫，但大致上於二十世紀中葉，第二次世界大戰之後，美國和歐洲有一種較緊密的盟友關係。在此之前，由於美洲在17世紀時期，曾是歐洲國家流放異見人士和囚犯的地方，所以，在美國開國1786年的初期，與歐洲殖民主義者，尤其是曾經統治過美國的英國，有著對立的關係。其後由於美國和歐洲長時期實施政治互不干預的政策，兩者在18至19世紀各自發展。20世紀的兩次世界大戰，令歐洲元氣大傷，但美國經濟卻有高度增長，西歐諸國均需要美國的經濟援助，自然靠近美國。再加上东欧诸国加入社会主义阵营，因而与美国关系降落冰点。冷战时期，以苏联为首的社会主义阵营的威脅加强除东欧外其他欧洲国家与美国的亲密度。但是在冷战结束后，威脅消失，欧洲（主要是欧盟成员国）与美国的关系发生一些变化，欧洲更需要有自己的声音，因此某些欧洲国家在九一一事件、伊拉克问题、以巴冲突等方面与美国产生不同意见，甚至有较大的分歧，但是其根深柢固的盟友关系还将保持不变。英國卻在上述事件中更加靠攏美國，與美國結成極為堅定的同盟關係，但也遭人取笑這個美國原屬的殖民主幾乎反倒成了美國的附庸。西班牙、波蘭等在美伊第二次戰爭時對美國的強力支持，使得美國稱讚這些國家為新歐洲，但隨著恐怖份子對西班牙發動攻擊，西班牙已退出與美國間的盟約，自伊拉克撤軍。

歐非 
歐洲和北非的關係，跟她與中東的關係差不多，因為北非與歐洲隔地中海相望，而北非亦是伊斯蘭教國家地區。歷史上，只有中世紀時期，阿拉伯帝國曾經統治過西班牙、葡萄牙和法國南部。自歐洲殖民主義興起，非洲各地成為歐洲的殖民地，法國在中非、西非和北非建立的法屬西非洲殖民地，是非洲大陸當時最大的殖民地。歐洲殖民主義者在非洲爭奪自然資源，情況直至1950年代開始非洲國家各民族的獨立運動浪潮，多個國家紛紛獨立，才有所改進。歐洲和非洲亦循著經貿的方向發展。

歐澳 
跟美國一樣，歐洲開發澳大利亞的初期亦以流放囚犯的作用。但由於歐洲和澳大利亞在地理上相距甚遠，令到兩者有著各位發展的空間，但在經濟、文化和宗親的聯繫上，澳大利亞和歐洲仍然有著很緊密的聯繫。澳大利亚及新西兰的主要移民群种均来源于欧洲，与当地土著民族及其他移民发展大洋洲。

内部政策差异 
虽然不少世界各国各项数据排名（如GDP、进出口总额、奥运会奖牌等）都将欧盟作为一个类似于主权国家的整体来看待，欧洲一体化的程度确实领先全球，但不同的欧洲国家在某些领域的内部政策方面仍然存在着明显的差异。

宗教政策 
欧洲是除东亚以外全球世俗化程度最高的地区。欧洲大部分国家皆已不设国教，但挪威、冰岛、芬兰的宪法仍规定基督新教路德宗为国教或唯一享受国家补贴的宗教，希腊宪法仍规定东正教为国教。

货币政策 
丹麦、瑞典、波兰、匈牙利、捷克、罗马尼亚、保加利亚等欧盟成员国至今未加入欧元区。

刑罚政策 
欧洲大部分国家不设死刑但保留无期徒刑，西班牙、葡萄牙、塞尔维亚、克罗地亚不设无期徒刑，但罪行特别严重的犯罪分子可能会被累计判处几百年甚至上千年的超长刑期。

擁有死刑法律的只有白俄羅斯。

毒品政策 
荷兰是唯一一个明文规定吸食和买卖大麻合法的欧洲国家。法国、希腊、瑞典、挪威、芬兰等国对大麻实行严厉的管制，无论是吸食还是买卖皆为违法，也不允许将大麻作为处方药使用。其他欧洲国家大都禁止私人种植和买卖大麻，但英国、德国、西班牙、比利时和捷克允许使用从大麻中提炼出的某些成分制造处方药。

性交易政策 
俄罗斯、瑞典、挪威、冰岛及东欧部分国家禁止一切形式的性交易，德国、荷兰、瑞士、奥地利、匈牙利、希腊、土耳其允许开设妓院卖淫，其余的欧洲国家允许性交易但禁止有组织地卖淫。

同性恋政策 
西欧大部分国家允许进行同性婚姻登记，義大利、捷克等国家则允许同性之间建立同居民事关系但不提供同性婚姻的注册登记，波兰、斯洛伐克、保加利亚等大部分东欧国家明文规定婚姻只能是异性之间的民事关系。

参見 

 歐洲聯盟
 斯堪的纳维亚
 欧洲議會
 歐元區
 欧洲一体化
 欧洲美元
 歐洲共同體
 歐洲委員會

注释

参考资料

引用

来源 

 网页
 "Europe". The Columbia Gazetteer of the World Online . 2005.  New York: Columbia University Press.

外部連結 

 
 歐洲歷史上不同时期的地图 

Europe

name: CI
on: [push, pull_request]

# Ensure only read permission is granted
permissions:
  contents: read

jobs:
  test:
    name: Test
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        include:
          - build: stable
            os: ubuntu-latest
            rust: stable
          - build: beta
            os: ubuntu-latest
            rust: beta
          - build: nightly
            os: ubuntu-latest
            rust: nightly
          - build: macos
            os: macos-latest
            rust: stable
          - build: win32
            os: windows-latest
            rust: stable-i686-pc-windows-msvc
          - build: win64
            os: windows-latest
            rust: stable-x86_64-pc-windows-msvc
          - build: mingw
            os: windows-latest
            rust: stable-x86_64-pc-windows-gnu
    steps:
    - uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v6.0.2
      with:
        persist-credentials: false
    - uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
      with:
        toolchain: ${{ matrix.rust }}
    - uses: taiki-e/install-action@0abfcd587b70a713fdaa7fb502c885e2112acb15 # v2.75.7
      with:
        tool: cargo-hack
    - run: cargo hack test --feature-powerset --exclude-features max_level_off,max_level_error,max_level_warn,max_level_info,max_level_debug,max_level_trace,release_max_level_off,release_max_level_error,release_max_level_warn,release_max_level_info,release_max_level_debug,release_max_level_trace
    - run: cargo run --verbose --manifest-path test_max_level_features/Cargo.toml
    - run: cargo run --verbose --manifest-path test_max_level_features/Cargo.toml --release

  check:
    name: Check Format and Clippy
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v6.0.2
      with:
        persist-credentials: false
    - uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
      with:
        toolchain: stable
        components: clippy
    - run: cargo fmt -- --check
    - run: cargo fmt --manifest-path test_max_level_features/Cargo.toml -- --check
    - run: cargo clippy --verbose
    - run: cargo clippy --verbose --manifest-path test_max_level_features/Cargo.toml

  doc:
    name: Check Documentation
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v6.0.2
      with:
        persist-credentials: false
    - uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
      with:
        toolchain: stable
    - name: Run rustdoc
      env:
        RUSTDOCFLAGS: "-D warnings"
      run: cargo doc --verbose --features std,kv,kv_std,kv_sval,kv_serde

  features:
    name: Feature check
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v6.0.2
        with:
          persist-credentials: false
      - uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
        with:
          toolchain: nightly
      - run: cargo build --verbose -Z avoid-dev-deps --features kv
      - run: cargo build --verbose -Z avoid-dev-deps --features "kv std"
      - run: cargo build --verbose -Z avoid-dev-deps --features "kv kv_sval"
      - run: cargo build --verbose -Z avoid-dev-deps --features "kv kv_serde"
      - run: cargo build --verbose -Z avoid-dev-deps --features "kv kv_std"
      - run: cargo build --verbose -Z avoid-dev-deps --features "kv kv_sval kv_serde"

  minimalv:
    name: Minimal versions
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v6.0.2
        with:
          persist-credentials: false
      - uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
        with:
          toolchain: nightly
      - run: cargo build --verbose -Z minimal-versions --features kv
      - run: cargo build --verbose -Z minimal-versions --features "kv std"
      - run: cargo build --verbose -Z minimal-versions --features "kv kv_sval"
      - run: cargo build --verbose -Z minimal-versions --features "kv kv_serde"
      - run: cargo build --verbose -Z minimal-versions --features "kv kv_std"
      - run: cargo build --verbose -Z minimal-versions --features "kv kv_sval kv_serde"

  msrv:
    name: MSRV
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v6.0.2
        with:
          persist-credentials: false
      - uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
        with:
          components: clippy
          toolchain: "1.71"
      - uses: taiki-e/install-action@0abfcd587b70a713fdaa7fb502c885e2112acb15 # v2.75.7
        with:
          tool: cargo-hack
      - run: cargo hack test --feature-powerset --exclude-features max_level_off,max_level_error,max_level_warn,max_level_info,max_level_debug,max_level_trace,release_max_level_off,release_max_level_error,release_max_level_warn,release_max_level_info,release_max_level_debug,release_max_level_trace
      - run: cargo run --verbose --manifest-path test_max_level_features/Cargo.toml
      - run: cargo run --verbose --manifest-path test_max_level_features/Cargo.toml --release

  embedded:
    name: Embedded
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@0c366fd6a839edf440554fa01a7085ccba70ac98 # v6.0.2
        with:
          persist-credentials: false
      - uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
        with:
          toolchain: stable
      - run: rustup target add thumbv6m-none-eabi riscv32imc-unknown-none-elf
      - run: cargo build --verbose --target=thumbv6m-none-eabi
      - run: cargo build --verbose --target=riscv32imc-unknown-none-elf

ดิมมูบอร์เกียร์ ( แปลว่า เมืองแห่งความมืด) เป็นวงดนตรีในแนวซิมโฟนิคแบล็กเมทัลจากประเทศนอร์เวย์ สามารถติดอันดับชาร์ตเพลงในประเทศกลุ่มสแกนดิเนเวียและในประเทศเยอรมนี และจัดได้ว่าเป็นวงแบล็กเมทัลที่ประสบความสำเร็จอย่างสูง

ดิมมูบอร์เกียร์ ในช่วงก่อตั้งนั้นเล่นดนตรีแนวแบล็กเมทัล ซึ่งต่อมาได้เปลี่ยนมาเล่นในแนวซิมโฟนิคแบล็กเมทัล

สมาชิกวง

สมาชิกวงปัจจุบัน
 Shagrath (Stian Thoresen)  - ร้องนำ (1993-ปัจจุบัน)
 Silenoz (Sven Atle Kopperud)  - กีต้าร์ (1993-ปัจจุบัน)
 Galder (Thomas Rune Andersen)  - กีต้าร์ (2000-ปัจจุบัน)
 Cyrus (Terje Andersen)  - กีต้าร์เบส (2011-ปัจจุบัน)
 Gerlioz (Geir Bratland)   - เสียงสังเคราะห์และคีย์บอร์ด (2011-ปัจจุบัน)
 Daray (Dariusz Brzozowski)   - กลอง (2008-ปัจจุบัน)

อดีตสมาชิก 
 Nicholas Barker - กลอง (1999-2005)
 Tjodalv - กลอง (1993-1999)
 Tony Laureano - กลอง (2004-2006)
 Astennu - กีตาร์ (1998-1999)
 Brynjard Tristan - กีต้าร์เบส (1993-1996)
 Nagash - กีต้าร์เบส (1996-1999)
 Stian Aarstad - คีย์บอร์ด (1993-1997)

ไทม์ไลน์

อัลบั้ม 
 Inn I Evighetens Morke (1994)
 For All Tid (1994, ออกอัลบั้มอีกครั้งในปี 1997)
 Stormblåst (1996)
 Devil's Path (1996)
 Enthrone Darkness Triumphant (1997; ออกอัลบั้มอีกครั้งในปี 2002)
 Godless Savage Garden (1998)
 Spiritual Black Dimensions (1999)
 Puritanical Euphoric Misanthropia (2001)
 Alive In Torment (2001)
 World Misanthropy CD (2002)
 Death Cult Armageddon (2003)
 Stormblåst (บันทึกเสียงใหม่)  (2005)
 In Sorte Diaboli  (2007)
 Abrahadabra  (2010)
Eonian (2018)

อ้างอิง 

กลุ่มดนตรีแบล็กเมทัล
กลุ่มดนตรีสัญชาตินอร์เวย์
กลุ่มดนตรีที่ก่อตั้งในปี พ.ศ. 2536

{
  "name": "pallets/click",
  "image": "mcr.microsoft.com/devcontainers/python:3",
  "customizations": {
    "vscode": {
      "settings": {
        "python.defaultInterpreterPath": "${workspaceFolder}/.venv",
        "python.terminal.activateEnvInCurrentTerminal": true,
        "python.terminal.launchArgs": [
          "-X",
          "dev"
        ]
      }
    }
  },
  "onCreateCommand": ".devcontainer/on-create-command.sh"
}

#![cfg(feature = "serde_core")]

use serde_core::de::{
    Deserialize, DeserializeSeed, Deserializer, EnumAccess, Error, Unexpected, VariantAccess,
    Visitor,
};
use serde_core::ser::{Serialize, Serializer};

use crate::{Level, LevelFilter, LOG_LEVEL_NAMES};

use std::fmt;
use std::str::{self, FromStr};

// The Deserialize impls are handwritten to be case-insensitive using FromStr.

impl Serialize for Level {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match *self {
            Level::Error => serializer.serialize_unit_variant("Level", 0, "ERROR"),
            Level::Warn => serializer.serialize_unit_variant("Level", 1, "WARN"),
            Level::Info => serializer.serialize_unit_variant("Level", 2, "INFO"),
            Level::Debug => serializer.serialize_unit_variant("Level", 3, "DEBUG"),
            Level::Trace => serializer.serialize_unit_variant("Level", 4, "TRACE"),
        }
    }
}

impl<'de> Deserialize<'de> for Level {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct LevelIdentifier;

        impl<'de> Visitor<'de> for LevelIdentifier {
            type Value = Level;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("log level")
            }

            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
            where
                E: Error,
            {
                let variant = LOG_LEVEL_NAMES[1..]
                    .get(v as usize)
                    .ok_or_else(|| Error::invalid_value(Unexpected::Unsigned(v), &self))?;

                self.visit_str(variant)
            }

            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
            where
                E: Error,
            {
                // Case-insensitive.
                FromStr::from_str(s).map_err(|_| Error::unknown_variant(s, &LOG_LEVEL_NAMES[1..]))
            }

            fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
            where
                E: Error,
            {
                let variant = str::from_utf8(value)
                    .map_err(|_| Error::invalid_value(Unexpected::Bytes(value), &self))?;

                self.visit_str(variant)
            }
        }

        impl<'de> DeserializeSeed<'de> for LevelIdentifier {
            type Value = Level;

            fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
            where
                D: Deserializer<'de>,
            {
                deserializer.deserialize_identifier(LevelIdentifier)
            }
        }

        struct LevelEnum;

        impl<'de> Visitor<'de> for LevelEnum {
            type Value = Level;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("log level")
            }

            fn visit_enum<A>(self, value: A) -> Result<Self::Value, A::Error>
            where
                A: EnumAccess<'de>,
            {
                let (level, variant) = value.variant_seed(LevelIdentifier)?;
                // Every variant is a unit variant.
                variant.unit_variant()?;
                Ok(level)
            }
        }

        deserializer.deserialize_enum("Level", &LOG_LEVEL_NAMES[1..], LevelEnum)
    }
}

impl Serialize for LevelFilter {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        match *self {
            LevelFilter::Off => serializer.serialize_unit_variant("LevelFilter", 0, "OFF"),
            LevelFilter::Error => serializer.serialize_unit_variant("LevelFilter", 1, "ERROR"),
            LevelFilter::Warn => serializer.serialize_unit_variant("LevelFilter", 2, "WARN"),
            LevelFilter::Info => serializer.serialize_unit_variant("LevelFilter", 3, "INFO"),
            LevelFilter::Debug => serializer.serialize_unit_variant("LevelFilter", 4, "DEBUG"),
            LevelFilter::Trace => serializer.serialize_unit_variant("LevelFilter", 5, "TRACE"),
        }
    }
}

impl<'de> Deserialize<'de> for LevelFilter {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        struct LevelFilterIdentifier;

        impl<'de> Visitor<'de> for LevelFilterIdentifier {
            type Value = LevelFilter;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("log level filter")
            }

            fn visit_u64<E>(self, v: u64) -> Result<Self::Value, E>
            where
                E: Error,
            {
                let variant = LOG_LEVEL_NAMES
                    .get(v as usize)
                    .ok_or_else(|| Error::invalid_value(Unexpected::Unsigned(v), &self))?;

                self.visit_str(variant)
            }

            fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
            where
                E: Error,
            {
                // Case-insensitive.
                FromStr::from_str(s).map_err(|_| Error::unknown_variant(s, &LOG_LEVEL_NAMES))
            }

            fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
            where
                E: Error,
            {
                let variant = str::from_utf8(value)
                    .map_err(|_| Error::invalid_value(Unexpected::Bytes(value), &self))?;

                self.visit_str(variant)
            }
        }

        impl<'de> DeserializeSeed<'de> for LevelFilterIdentifier {
            type Value = LevelFilter;

            fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
            where
                D: Deserializer<'de>,
            {
                deserializer.deserialize_identifier(LevelFilterIdentifier)
            }
        }

        struct LevelFilterEnum;

        impl<'de> Visitor<'de> for LevelFilterEnum {
            type Value = LevelFilter;

            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                formatter.write_str("log level filter")
            }

            fn visit_enum<A>(self, value: A) -> Result<Self::Value, A::Error>
            where
                A: EnumAccess<'de>,
            {
                let (level_filter, variant) = value.variant_seed(LevelFilterIdentifier)?;
                // Every variant is a unit variant.
                variant.unit_variant()?;
                Ok(level_filter)
            }
        }

        deserializer.deserialize_enum("LevelFilter", &LOG_LEVEL_NAMES, LevelFilterEnum)
    }
}

#[cfg(test)]
mod tests {
    use crate::{Level, LevelFilter};
    use serde_test::{assert_de_tokens, assert_de_tokens_error, assert_tokens, Token};

    fn level_token(variant: &'static str) -> Token {
        Token::UnitVariant {
            name: "Level",
            variant,
        }
    }

    fn level_bytes_tokens(variant: &'static [u8]) -> [Token; 3] {
        [
            Token::Enum { name: "Level" },
            Token::Bytes(variant),
            Token::Unit,
        ]
    }

    fn level_variant_tokens(variant: u32) -> [Token; 3] {
        [
            Token::Enum { name: "Level" },
            Token::U32(variant),
            Token::Unit,
        ]
    }

    fn level_filter_token(variant: &'static str) -> Token {
        Token::UnitVariant {
            name: "LevelFilter",
            variant,
        }
    }

    fn level_filter_bytes_tokens(variant: &'static [u8]) -> [Token; 3] {
        [
            Token::Enum {
                name: "LevelFilter",
            },
            Token::Bytes(variant),
            Token::Unit,
        ]
    }

    fn level_filter_variant_tokens(variant: u32) -> [Token; 3] {
        [
            Token::Enum {
                name: "LevelFilter",
            },
            Token::U32(variant),
            Token::Unit,
        ]
    }

    #[test]
    fn test_level_ser_de() {
        let cases = &[
            (Level::Error, [level_token("ERROR")]),
            (Level::Warn, [level_token("WARN")]),
            (Level::Info, [level_token("INFO")]),
            (Level::Debug, [level_token("DEBUG")]),
            (Level::Trace, [level_token("TRACE")]),
        ];

        for (s, expected) in cases {
            assert_tokens(s, expected);
        }
    }

    #[test]
    fn test_level_case_insensitive() {
        let cases = &[
            (Level::Error, [level_token("error")]),
            (Level::Warn, [level_token("warn")]),
            (Level::Info, [level_token("info")]),
            (Level::Debug, [level_token("debug")]),
            (Level::Trace, [level_token("trace")]),
        ];

        for (s, expected) in cases {
            assert_de_tokens(s, expected);
        }
    }

    #[test]
    fn test_level_de_bytes() {
        let cases = &[
            (Level::Error, level_bytes_tokens(b"ERROR")),
            (Level::Warn, level_bytes_tokens(b"WARN")),
            (Level::Info, level_bytes_tokens(b"INFO")),
            (Level::Debug, level_bytes_tokens(b"DEBUG")),
            (Level::Trace, level_bytes_tokens(b"TRACE")),
        ];

        for (value, tokens) in cases {
            assert_de_tokens(value, tokens);
        }
    }

    #[test]
    fn test_level_de_variant_index() {
        let cases = &[
            (Level::Error, level_variant_tokens(0)),
            (Level::Warn, level_variant_tokens(1)),
            (Level::Info, level_variant_tokens(2)),
            (Level::Debug, level_variant_tokens(3)),
            (Level::Trace, level_variant_tokens(4)),
        ];

        for (value, tokens) in cases {
            assert_de_tokens(value, tokens);
        }
    }

    #[test]
    fn test_level_de_error() {
        let msg = "unknown variant `errorx`, expected one of \
                   `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`";
        assert_de_tokens_error::<Level>(&[level_token("errorx")], msg);
    }

    #[test]
    fn test_level_filter_ser_de() {
        let cases = &[
            (LevelFilter::Off, [level_filter_token("OFF")]),
            (LevelFilter::Error, [level_filter_token("ERROR")]),
            (LevelFilter::Warn, [level_filter_token("WARN")]),
            (LevelFilter::Info, [level_filter_token("INFO")]),
            (LevelFilter::Debug, [level_filter_token("DEBUG")]),
            (LevelFilter::Trace, [level_filter_token("TRACE")]),
        ];

        for (s, expected) in cases {
            assert_tokens(s, expected);
        }
    }

    #[test]
    fn test_level_filter_case_insensitive() {
        let cases = &[
            (LevelFilter::Off, [level_filter_token("off")]),
            (LevelFilter::Error, [level_filter_token("error")]),
            (LevelFilter::Warn, [level_filter_token("warn")]),
            (LevelFilter::Info, [level_filter_token("info")]),
            (LevelFilter::Debug, [level_filter_token("debug")]),
            (LevelFilter::Trace, [level_filter_token("trace")]),
        ];

        for (s, expected) in cases {
            assert_de_tokens(s, expected);
        }
    }

    #[test]
    fn test_level_filter_de_bytes() {
        let cases = &[
            (LevelFilter::Off, level_filter_bytes_tokens(b"OFF")),
            (LevelFilter::Error, level_filter_bytes_tokens(b"ERROR")),
            (LevelFilter::Warn, level_filter_bytes_tokens(b"WARN")),
            (LevelFilter::Info, level_filter_bytes_tokens(b"INFO")),
            (LevelFilter::Debug, level_filter_bytes_tokens(b"DEBUG")),
            (LevelFilter::Trace, level_filter_bytes_tokens(b"TRACE")),
        ];

        for (value, tokens) in cases {
            assert_de_tokens(value, tokens);
        }
    }

    #[test]
    fn test_level_filter_de_variant_index() {
        let cases = &[
            (LevelFilter::Off, level_filter_variant_tokens(0)),
            (LevelFilter::Error, level_filter_variant_tokens(1)),
            (LevelFilter::Warn, level_filter_variant_tokens(2)),
            (LevelFilter::Info, level_filter_variant_tokens(3)),
            (LevelFilter::Debug, level_filter_variant_tokens(4)),
            (LevelFilter::Trace, level_filter_variant_tokens(5)),
        ];

        for (value, tokens) in cases {
            assert_de_tokens(value, tokens);
        }
    }

    #[test]
    fn test_level_filter_de_error() {
        let msg = "unknown variant `errorx`, expected one of \
                   `OFF`, `ERROR`, `WARN`, `INFO`, `DEBUG`, `TRACE`";
        assert_de_tokens_error::<LevelFilter>(&[level_filter_token("errorx")], msg);
    }
}

<!doctype html>
<html lang="en">
  <head>
    <meta charset="utf-8">
    <title>lodash Performance Suite</title>
    <style>
      html, body {
        margin: 0;
        padding: 0;
        height: 100%;
      }
      #FirebugUI {
        top: 2.5em;
      }
      #perf-toolbar {
        background-color: #EEE;
        color: #5E740B;
        font-family: "Helvetica Neue Light", "HelveticaNeue-Light", "Helvetica Neue", Calibri, Helvetica, Arial, sans-serif;
        font-size: small;
        padding: 0.5em 1em 0.5em 1em;
        overflow: hidden;
      }
      #perf-toolbar label {
        display: inline-block;
        margin-right: 0.5em;
      }
      #perf-toolbar span {
        display: inline-block;
        float: right;
        line-height: 2.1em;
        margin-left: 1em;
        margin-top: 0;
      }
    </style>
  </head>
  <body>
    <div id="perf-toolbar"></div>
    <script src="../lodash.js"></script>
    <script src="../node_modules/platform/platform.js"></script>
    <script src="../node_modules/benchmark/benchmark.js"></script>
    <script src="../vendor/firebug-lite/src/firebug-lite-debug.js"></script>
    <script src="./asset/perf-ui.js"></script>
    <script>
      document.write('<script src="' + ui.buildPath + '"><\/script>');
    </script>
    <script>
      var lodash = _.noConflict();
    </script>
    <script>
      document.write('<script src="' + ui.otherPath + '"><\/script>');
    </script>
    <script src="perf.js"></script>
    <script>
      (function() {
        var measured,
            perfNow,
            begin = new Date;

        function init() {
          var fbUI = document.getElementById('FirebugUI'),
              fbDoc = fbUI && (fbDoc = fbUI.contentWindow || fbUI.contentDocument).document || fbDoc,
              fbCommandLine = fbDoc && fbDoc.getElementById('fbCommandLine');

          if (!fbCommandLine) {
            return setTimeout(init, 15);
          }
          fbUI.style.height = (
            Math.max(document.documentElement.clientHeight, document.body.clientHeight) -
            document.getElementById('perf-toolbar').clientHeight
          ) + 'px';

          fbDoc.body.style.height = fbDoc.documentElement.style.height = '100%';
          setTimeout(run, 15);
        }

        window.onload = init;
      }());
    </script>
  </body>
</html>

Bali (juga dikenal sebagai Kepulauan Bali, ) adalah sebuah wilayah provinsi yang terletak di Indonesia. Ibu kotanya adalah Denpasar. Provinsi Bali terletak di bagian barat Kepulauan Nusa Tenggara. Di awal kemerdekaan Indonesia, pulau ini termasuk dalam Provinsi Sunda Kecil yang beribu kota di Singaraja, dan kini terbagi menjadi 3 provinsi, yakni Bali, Nusa Tenggara Barat, dan Nusa Tenggara Timur . Pada tahun 2020, penduduk provinsi Bali berjumlah 4.317.404 jiwa, dengan kepadatan 747 jiwa/km2.

Selain terdiri dari pulau Bali, wilayah provinsi Bali juga terdiri dari pulau-pulau yang lebih kecil di sekitarnya, yaitu pulau Nusa Penida, pulau Nusa Lembongan, pulau Nusa Ceningan, Pulau Serangan, dan Pulau Menjangan. Secara geografis, Bali terletak di antara Pulau Jawa dan Pulau Lombok. Mayoritas penduduk Bali adalah pemeluk agama Hindu. Di dunia, Bali terkenal sebagai tujuan pariwisata dengan keunikan berbagai hasil seni-budayanya dan juga mitosnya, khususnya bagi para wisatawan Jepang dan Australia. Bali juga dikenal dengan julukan Pulau Dewata dan Pulau Seribu Pura.

Geografi 

Pulau Bali adalah bagian dari Kepulauan Sunda Kecil sepanjang 153 km dan selebar 112 km sekitar 3,2 km dari Pulau Jawa. Secara geografis, Bali terletak di 8°25′23″ Lintang Selatan dan 115°14′55″ Bujur Timur yang membuatnya beriklim tropis seperti bagian Indonesia yang lain.

Gunung Agung adalah titik tertinggi di Bali setinggi 3.148 m. Gunung berapi ini terakhir meletus pada Maret 1963. Gunung Batur juga salah satu gunung yang ada di Bali. Sekitar 30.000 tahun yang lalu, Gunung Batur meletus dan menghasilkan bencana yang dahsyat di bumi. Berbeda dengan di bagian utara, bagian selatan Bali adalah dataran rendah yang dialiri sungai-sungai.

Berdasarkan relief dan topografi, di tengah-tengah Pulau Bali terbentang pegunungan yang memanjang dari barat ke timur dan di antara pegunungan tersebut terdapat gugusan gunung berapi yaitu Gunung Batur dan Gunung Agung serta gunung yang tidak berapi, yaitu Gunung Merbuk, Gunung Patas dan Gunung Seraya. Adanya pegunungan tersebut menyebabkan Daerah Bali secara Geografis terbagi menjadi 2 (dua) bagian yang tidak sama yaitu Bali Utara dengan dataran rendah yang sempit dan kurang landai dan Bali Selatan dengan dataran rendah yang luas dan landai. 

Kemiringan lahan Pulau Bali terdiri dari lahan datar (0-2%) seluas 122.652 ha, lahan bergelombang (2-15%) seluas 118.339 ha, lahan curam (15-40%) seluas 190.486 ha dan lahan sangat curam (>40%) seluas 132.189 ha. Provinsi Bali memiliki 4 (empat) buah danau yang berlokasi di daerah pegunungan, yaitu Danau Beratan atau Bedugul, Buyan, Tamblingan, dan Batur. Alam Bali yang indah menjadikan pulau Bali terkenal sebagai daerah wisata.

Ibu kota Bali adalah Denpasar. Tempat-tempat penting lainnya adalah Ubud sebagai pusat kesenian dan peristirahatan, terletak di Kabupaten Gianyar. Nusa Lembongan adalah sebagai salah satu tempat menyelam (diving), terletak di Kabupaten Klungkung. Sedangkan Kuta, Seminyak, Jimbaran dan Nusa Dua adalah beberapa tempat yang menjadi tujuan utama pariwisata, baik wisata pantai maupun tempat peristirahatan, spa, dan lain-lain, terletak di Kabupaten Badung.

Luas wilayah Provinsi Bali adalah 5.636,66 km2 atau 0,29% luas wilayah Negara Kesatuan Republik Indonesia. Secara administratif Provinsi Bali terbagi atas 8 kabupaten, 1 kotamadya, 55 kecamatan, dan 701 desa/kelurahan.

Batas wilayah

Sejarah 

Jepang menduduki Bali selama Perang Dunia II dan saat itu seorang perwira militer bernama I Gusti Ngurah Rai membentuk pasukan Bali 'pejuang kemerdekaan'. Menyusul menyerahnya Jepang di Pasifik pada bulan Agustus 1945, Belanda segera kembali ke Indonesia (termasuk Bali) untuk menegakkan kembali pemerintahan kolonialnya layaknya keadaan sebelum perang. Hal ini ditentang oleh pasukan perlawanan Bali yang saat itu menggunakan senjata Jepang.

Pada 20 November 1946, pecahlah pertempuran Puputan Margarana yang terjadi di Uma Kaang, Desa Marga, Kabupaten Tabanan, Bali. Kolonel I Gusti Ngurah Rai yang berusia 29 tahun, memimpin tentaranya dari wilayah timur Bali untuk melakukan serangan sampai mati pada pasukan Belanda yang bersenjata lengkap. Seluruh anggota batalion Bali tersebut tewas  dan menjadikannya sebagai perlawanan militer Bali yang terakhir.

Pada tahun 1946, Belanda menjadikan Bali sebagai salah satu dari 13 wilayah bagian dari Negara Indonesia Timur yang baru diproklamasikan, yaitu sebagai salah satu negara saingan bagi Republik Indonesia yang diproklamasikan dan dikepalai oleh Sukarno dan Hatta. Bali kemudian juga dimasukkan ke dalam Republik Indonesia Serikat ketika Belanda mengakui kemerdekaan Indonesia pada 29 Desember 1949. Tahun 1950, secara resmi Bali meninggalkan perserikatannya dengan Belanda dan secara hukum menjadi sebuah provinsi dari Republik Indonesia.

Letusan Gunung Agung yang terjadi pada tahun 1963, sempat mengguncangkan perekonomian rakyat dan menyebabkan banyak penduduk Bali bertransmigrasi ke berbagai wilayah lain di Indonesia.

Tahun 1965, seiring dengan gagalnya kudeta oleh G30S terhadap pemerintah nasional di Jakarta, Bali dan banyak daerah lainnya, terjadilah penumpasan terhadap anggota dan simpatisan Partai Komunis Indonesia. Di Bali, diperkirakan lebih dari 100.000 orang terbunuh atau hilang. Meskipun demikian, kejadian-kejadian pada masa awal Orde Baru tersebut sampai dengan saat ini belum berhasil diungkapkan secara hukum.

Serangan teroris telah terjadi pada 12 Oktober 2002, berupa serangan Bom Bali I di kawasan pariwisata Kuta tepatnya Legian, menyebabkan sebanyak 202 orang tewas dan 209 orang lainnya cedera. Serangan Bom Bali II tahun 2005 juga terjadi tiga tahun kemudian di Kuta dan pantai Jimbaran. Kejadian-kejadian tersebut mendapat liputan internasional yang luas karena sebagian besar korbannya adalah wisatawan asing dan menyebabkan industri pariwisata Bali menghadapi tantangan berat beberapa tahun terakhir ini.

Pemerintahan

Gubernur 

Gubernur menjadi pejabat tertinggi di pemerintahan provinsi Bali. Gubernur Bali bertanggungjawab atas wilayah Provinsi Bali. Saat ini, gubernur atau kepala daerah yang menjabat di provinsi Bali ialah I Wayan Koster, didampingi wakil gubernur Tjokorda Oka Artha Ardana Sukawati atau sering disapa Cok Ace. Mereka menang pada Pemilihan umum Gubernur Bali 2018. Wayan Koster merupakan gubernur Bali yang ke-9, sejak provinsi ini dibentuk menjadi provinsi Bali tahun 1958 berdasarkan Undang-undang Nomor 64 Tahun 1958. Koster dan Cok Ace dilantik oleh presiden Republik Indonesia Joko Widodo, di Istana Negara Jakarta pada 5 September 2018, untuk masa jabatan 2018-2023.

Dewan Perwakilan Rakyat

Dewan Perwakilan Daerah 
Empat anggota DPD (2019-2024) dari Provinsi Bali adalah;
 Shri I.G.N. Arya Wedakarna M Wedasteraputra S
 I Made Mangku Pastika
 Anak Agung Gde Agung
 Bambang Santoso

Berdasarkan hasil Pemilihan Umum Legislatif 2019, Bali mengirimkan sembilan anggota DPR ke DPR RI. Pada tingkat provinsi, DPRD Bali dengan 55 kursi tersedia dikuasai oleh PDI-P dengan 33 kursi, disusul Partai Golkar dengan 8 kursi, dan Partai Gerindra dengan 6 kursi.

Daftar kabupaten dan kota di Bali

Demografi

Agama  

Berdasarkan data Badan Pusat Statistik (BPS) provinsi Bali tahun 2021, penduduk Bali berjumlah 4.317.404 jiwa (2020) dengan mayoritas etnis Bali. Data Kementerian Agama mencatat bahwa 86,70% warga provinsi Bali menganut agama Hindu. Agama lainnya adalah Islam sebanyak 10,10%, kemudian Kristen Protestan sebanyak 1,67%, Katolik sebanyak 0,83%, Budha sebanyak 0,68%, Konghucu sebanyak 0,01%, dan penganut kepercayaan kurang dari 0,01%.

Masyarakat suku Bali umumnya beragama Hindu. Sementara penduduk Jawa, Sunda, Sasak, Melayu, umumnya beragama Islam, dan beberapa orang asli suku Bali juga ada yang memeluk agama Islam. Sementara pemeluk agama Kristen umumnya berasal dari penduduk Nusa Tenggara Timur, kemudian Papua, suku Batak, Minahasa, Tionghoa. Dan ada juga satu desa yakni desa Blimbing Sari di kecamatan Melaya Jembrana, tidak jauh dari Pelabuhan Gilimanuk, sebuah desa Kristen di mana warganya adalah asli suku Bali, bahkan gerejanya bentuknya mirip Pura.

Suku bangsa 

Mayoritas penduduk yang mendiami provinsi Bali adalah suku asli setempat, yakni Bali. Suku Bali memiliki kekayaan budaya yang dikenal dunia, sehingga Bali menjadi tujuan utama wisatawan asing ke Indonesia. Selain kekayaan pantai, budaya yang diminati di Bali adalah tari-tariannya, seperti tari Kecak, festival seperti Ogoh-ogoh, dan lainnya. Suku terbanyak dari luar suku Bali adalah suku Jawa.

Berdasarkan data dari Sensus Penduduk Indonesia 2010, berikut ini komposisi etnis atau suku bangsa di provinsi Bali:

Bahasa 

Selain dari sektor pariwisata, penduduk Bali juga hidup dari pertanian dan perikanan, yang paling dikenal dunia dari pertanian di Bali ialah sistem Subak. Sebagian juga memilih menjadi seniman. Bahasa yang digunakan di Bali adalah bahasa Indonesia, Bali dan Inggris khususnya bagi yang bekerja di sektor pariwisata.

Bahasa Bali dan bahasa Indonesia adalah bahasa yang paling luas pemakaiannya di Bali dan sebagaimana penduduk Indonesia lainnya, sebagian besar masyarakat Bali adalah bilingual atau bahkan trilingual. Meskipun terdapat beberapa dialek dalam bahasa Bali, umumnya masyarakat Bali menggunakan sebentuk bahasa Bali pergaulan sebagai pilihan dalam berkomunikasi. Secara tradisi, penggunaan berbagai dialek bahasa Bali ditentukan berdasarkan sistem catur warna dalam agama Hindu Dharma dan keanggotan klan (istilah Bali: soroh, gotra); meskipun pelaksanaan tradisi tersebut cenderung berkurang.

Bahasa Inggris adalah bahasa ketiga (dan bahasa asing utama) bagi banyak masyarakat Bali yang dipengaruhi oleh kebutuhan yang besar dari industri pariwisata. Para karyawan yang bekerja pada pusat-pusat informasi wisatawan di Bali, sering kali juga memahami beberapa bahasa asing dengan kompetensi yang cukup memadai. Bahasa Jepang juga menjadi prioritas pendidikan di Bali.

Masyarakat Bali menggunakan bahasa Bali sebagai bahasa komunikasi antar sesama orang Bali selain bahasa Indonesia dan bahasa Inggris. Bahasa Bali merupakan subkelompok dari rumpun bahasa Austronesia Barat, dipergunakan oleh sekitar tiga juta penutur. Bahasa Bali memiliki fungsi dan kedudukan yang penting dalam kehidupan masyarakat Bali terutama pada topik-topik pembicaraan yang bersifat tradisional seperti pembicaraan masalah adat (dalam rapat atau pertemuan yang disebut sangkep) kebudayaan dan agama (Hindu).

Bahasa Bali terdiri atas dua dialek:
 Dialek Bali Aga atau Bali Mula yang dituturkan oleh penduduk Bali di daerah dataran tinggi di Bali
 Dialek Bali Dataran yang dituturkan oleh penduduk yang pada umumnya berdiam di daerah dataran rendah di Bali.

Masyarakat yang menggunakan dialek Bali Aga disebut masyarakat Bali Aga dan bermukim di wilayah pegunungan. Daerah pengguna dialek Bali Aga meliputi Kabupaten Karangasem, yaitu di Desa Tenganan, Kecamatan Manggis dan Desa Seraya, Kecamatan Karangasem; Kabupaten Bangli, yaitu di Desa Terunyan dan Kecamatan Kintamani; Kabupaten Klungkung, yaitu di Desa Klumpu, Kecamatan Nusa Penida; Kabupaten Badung bagian utara, yaitu di Kecamatan  Petang; Kabupaten Tabanan, yaitu di Desa Wongaya Gede, Kecamatan Penebel; Kabupaten Buleleng, yaitu di Desa Sepang, Kecamatan Busung Biu; Kabupaten Jembrana, yaitu di Desa Nusasari, Kecamatan Melaya. Selain itu, bahasa Bali juga dituturkan di berbagai daerah lainnya di Indonesia, yakni di Nusa Tenggara Barat, Lampung, Sulawesi Tenggara, Jawa Timur dan Kalimantan Tengah khususnya di Kabupaten Kapuas.

Dialek Bali Dataran digunakan oleh masyarakat Bali yang bertempat tinggal di daerah pesisir atau dataran rendah di Bali, baik di bagian utara Bali maupun bagian selatan Bali. Dialek Bali Dataran menyebar hampir di seluruh wilayah di Bali. Adapun wilayah yang menggunakan dialek bali dataran seperti Kabupaten Klungkung dari wilayah utara di kecamatan Banjarangkan yaitu Desa Bumbungan; Kabupaten Jembrana, yaitu desa Pengragoan, kecamatan Pekutatan; Kabupaten Tabanan, yaitu di desa Bantas, kecamatan Selemadeg Timur dan desa Luwus, kecamatan Baturiti; Kabupaten Badung, yaitu di desa Baha, kecamatan Mengwi dan Desa Pecatu, Kecamatan Kuta Selatan; Kota Denpasar yaitu di Kampung Kepoan, Desa Pemogan, Kecamatan Denpasar Selatan; Kabupaten Gianyar, yaitu di Desa Pupuan, Kecamatan Tegalalang dan Desa Saba, Kecamatan Blahbatuh; Kabupaten Klungkung, yaitu di Kampung Toyapakeh, Kecamatan Nusa Penida dan Kampung Gelgel, Kecamatan Klungkung; Kabupaten Karangasem, yaitu di Desa Bebandem dan Kampung Kecicang Muslim, Desa Bungaya Kangin,  Kecamatan Bebanden serta Desa Tianyar, Kecamatan Kubu; Kabupaten Bangli, yaitu di Desa Jehem, Kecamatan Tembuku; Kabupaten Buleleng, yaitu di Desa Bukti, Kecamatan Kubutambahan, Desa Pegayaman, Kecamatan Sukasada, Desa Kayu Putih, Kecamatan Banjar, dan Desa Banyupoh, Kecamatan Gerokgak.

Bahasa Bali mengenal sistem sor singgih atau tingkatan-tingkatan berbahasa terutama bahasa Bali Dataran karena mendapatkan pengaruh dari Jawa. Tingkatan-tingkatan berbahasa tersebut masih dipertahankan hingga kini oleh masyarakata Bali terutama dalam ranah-ranah tradisional. Sistem Pelapisan sosial masyarakat Bali yang dikenal dengan catur warna sangat besar pengaruhnya terhadap penggunaan Bahasa Bali. Masing-masing kelas sosial dalam masyarakat Bali akan menggunakan bahasa Bali sesuai dengan siapa yang diajak bicara. Seorang sudra akan berbicara dengan bahasa Bali halus kepada seseorang dari kasta brahmana.

Bahasa Bali terus mengalami perkembangan terutama bahasa Bali dataran yang disebut sebagai bahasa bali standar. Berdasarkan hasil keputusan Pesamuhan Agung Bahasa Bali yang diadakan tahun 1974 bahasa Bali standar atau baku digunakan oleh masyarakat Bali dalam sekolah-sekolah, pertemuan-pertemuan, surat menyurat, kesusastraan, media massa elektronik dan cetak, adat dan budaya. Bahasa Bali baku ini mengacu pada bahasa yang digunakan oleh masyarakat tutur bahasa Bali yang berdomisili di Klungkung dan kota Singaraja, hal ini disebabkan karena kedua wilayah ini cukup lama menjadi pusat kekuasaan politik, ekonomi dan kebudayaan Bali. Selain itu, bahasa Bali di kedua daerah tersebut memiliki ciri yang sama baik secara fonologis maupun sintaksis.

Terdapat perbedaan yang cukup kentara dari bahasa Bali yang dituturkan di luar Bali dengan yang dituturkan di daerah Bali dan dari dialek Bali Aga dengan dialek Bali Dataran. Berdasarkan perhitungan dialektometri, persentase perbedaan yang terukur antara dialek Bali Aga dengan dialek Bali Dataran adalah sebesar 60%. Jika ditinjau lebih luas lagi terhadap daerah luar Bali, isolek Bali yang berada di pulau Bali memiliki perbedaan sebesar 71,75% dengan bahasa Bali di Nusa Tenggara Barat; sebesar 69,5% jika dibandingkan dengan bahasa Bali di Jawa Timur; sebesar 77,5% jika dibandingkan dengan bahasa Bali di Lampung; dan sebesar 76,75% jika dibandingkan dengan bahasa Bali di Sulawesi Tenggara.

Ekonomi 

Tiga dekade lalu, perekonomian Bali sebagian besar mengandalkan dan berbasis pada pertanian baik dari segi output dan kesempatan kerja. Sekarang, industri pariwisata menjadi objek pendapatan terbesar bagi Bali. Hasilnya, Bali menjadi salah satu daerah terkaya di Indonesia. Pada tahun 2003, sekitar 80% perekonomian Bali bergantung pada industri pariwisata. Pada akhir Juni 2011, non-performing loan dari semua bank di Bali adalah 2,23%, lebih rendah dari rata-rata non-performing loan industri perbankan Indonesia (sekitar 5%). Ekonomi, bagaimanapun menderita secara signifikan sebagai akibat dari Bom Bali I tahun 2002 dan Bom Bali II tahun 2005. Industri pariwisata sendiri telah pulih dari akibat peristiwa ini. Pasca terjadinya Pandemi Covid-19 akhir tahun 2019, perekonomian Bali yang didominasi sektor Pariwisata, mengalami penurunan. Akan tetapi, sektor pertanian menjadi salah satu penopang utama perekonomian di provinsi Bali.

Pariwisata 

Bali adalah primadona pariwisata Indonesia yang sudah terkenal di seluruh dunia. Selain terkenal dengan keindahan alam, terutama pantainya, Bali juga terkenal dengan kesenian dan budayanya yang unik dan menarik. Industri pariwisata berpusat di Bali Selatan dan di beberapa daerah lainnya. Lokasi wisata yang utama adalah Kuta dan sekitarnya seperti Legian dan Seminyak, Sanur, Ubud, dan di daerah selatan seperti Jimbaran, Nusa Dua dan Pecatu.

Bali sebagai tempat tujuan wisata yang lengkap dan terpadu memiliki banyak sekali tempat wisata menarik, antara lain: Pantai Kuta, Pura Tanah Lot, Pantai Padang–Padang, Danau Beratan Bedugul, Garuda Wisnu Kencana (GWK), Pantai Lovina dengan Lumba Lumbanya, Pura Besakih, Uluwatu, Tegallalang, Ubud, Munduk, Kintamani, Amed, Tulamben, Pulau Menjangan dan masih banyak yang lainnya. Kini, Bali juga memiliki beberapa pusat wisata yang sarat edukasi untuk anak-anak seperti kebun binatang, museum tiga dimensi, taman bermain air, dan tempat penangkaran kura-kura.

Transportasi 

Bali tidak memiliki jaringan rel kereta api namun jaringan jalan yang ada di pulau ini tergolong sangat baik dibanding daerah-daerah lain di Indonesia, jaringan jalan tersedia dengan baik khususnya ke daerah-daerah tujuan wisatawan yakni Legian, Kuta, Sanur, Nusa Dua, Ubud, dll. Sebagian besar penduduk memiliki kendaraan pribadi dan memilih menggunakannya karena moda transportasi umum tidak tersedia dengan baik, kecuali taksi dan angkutan pariwisata. Moda transportasi massal saat ini disiapkan agar Bali mampu memberi kenyamanan lebih terhadap para wisatawan.

Sampai sekarang, transportasi di Bali umumnya dibangun di Bali bagian selatan sekitar Denpasar, Kuta, Nusa Dua, dan Sanur sedangkan wilayah utara kurang memiliki akomodasi yang baik.

Jenis kendaraan umum di Bali atara lain:
 Dokar, kendaraan dengan menggunakan kuda sebagai penarik dikenal sebagai delman di tempat lain.
 Ojek, taksi sepeda motor (sebagian sudah berbasis di intenet).
 Bemo/angkot, melayani dalam dan antarkota.
 Teman Bus yang melayani berbagai rute di wilayah sarbagita dan sekarang rencananya akan merambah daerah Bangli. 
 Taksi (sebagian sudah mempunyai aplikasi di smartphone).
 Komotra, bus yang melayani perjalanan ke kawasan pantai Kuta dan sekitarnya.
 Bus, melayani hubungan antarkota, pedesaan, dan antarprovinsi.

Bali terhubung dengan pulau Jawa dengan layanan kapal feri yang menghubungkan Pelabuhan Gilimanuk di kabupaten Jembrana dengan Pelabuhan Ketapang di Kabupaten Banyuwangi yang lama tempuhnya sekitar 30 hingga 45 menit saja. Penyeberangan ke Pulau Lombok melalui Pelabuhan Padangbai menuju Pelabuhan Lembar yang memakan waktu sekitar empat sampai lima jam lamanya tergantung cuaca.

Transportasi udara dilayani oleh Bandara Internasional Ngurah Rai dengan destinasi ke sejumlah kota besar di Indonesia, Australia, Singapura, Malaysia, Thailand, Timor Leste, RRC serta Jepang. Landas pacu dan pesawat terbang yang datang dan pergi bisa terlihat dengan jelas dari pantai dan menjadi semacam hiburan tambahan bagi para wisatawan yang menikmati pantai Bali.

Untuk transportasi darat antar pulau di bali ada terminal Ubung-Denpasar dan terminal Mengwi yang menghubungkan pulau Bali dengan Pulau Jawa dan Pulau Lombok. Terminal Ubung di pulau Bali ini melayani berbagai rute antar pulau tujuan Jakarta, Bandung, Semarang, Yogyakarta, Surabaya, Malang, Madura, Jember, dll. Angkutan antar pulau dilayani oleh armada bus besar dengan kelas ekonomi, bisnis dan eksekutif. Terminal Ubung relatif ramai mulai pukul 15.00–18.00 WITA karena pada jam tersebut banyak bus yang mulai berangkat ke kota tujuan masing-masing. Bagi anda yang datang ke terminal ini harap waspada karena banyak calo tiket yang agak memaksa penumpang.

Budaya

Rumah Adat 

Rumah Bali yang sesuai dengan aturan Asta Kosala Kosali (bagian Weda yang mengatur tata letak ruangan dan bangunan).

Menurut filosofi masyarakat Bali, kedinamisan dalam hidup akan tercapai apabila terwujudnya hubungan yang harmonis antara aspek pawongan, palemahan dan parahyangan. Untuk itu pembangunan sebuah rumah harus meliputi aspek-aspek tersebut atau yang biasa disebut Tri Hita Karana. Pawongan merupakan para penghuni rumah. Palemahan berarti harus ada hubungan yang baik antara penghuni rumah dan lingkungannya.

Pada umumnya bangunan atau arsitektur tradisional daerah Bali selalu dipenuhi hiasan, berupa ukiran, peralatan serta pemberian warna. Ragam hias tersebut mengandung arti tertentu sebagai ungkapan keindahan simbol-simbol dan penyampaian komunikasi. Bentuk-bentuk ragam hias dari jenis fauna juga berfungsi sebagai simbol-simbol ritual yang ditampilkan dalam patung.

Musik 

Musik tradisional Bali memiliki kesamaan dengan musik tradisional di banyak daerah lainnya di Indonesia, misalnya dalam penggunaan gamelan dan berbagai alat musik tabuh lainnya. Meskipun demikian, terdapat kekhasan dalam teknik memainkan dan gubahannya, misalnya dalam bentuk kecak, yaitu sebentuk nyanyian yang konon menirukan suara kera. Demikian pula beragam gamelan yang dimainkan, misalnya gamelan jegog, gamelan gong gede(gamelan jawa kuno), gamelan gambang, gamelan selunding dan gamelan Semar Pegulingan. Ada pula musik Angklung dimainkan untuk upacara ngaben serta musik Bebonangan dimainkan dalam berbagai upacara lainnya.

Terdapat bentuk modern dari musik tradisional Bali, misalnya Gamelan Gong Kebyar yang merupakan musik tarian yang dikembangkan pada masa penjajahan Belanda serta Joged Bumbung yang mulai populer di Bali sejak era tahun 1950-an. Umumnya musik Bali merupakan kombinasi dari berbagai alat musik perkusi metal (metalofon), gong dan perkusi kayu (xilofon). Karena hubungan sosial, politik dan budaya, musik tradisional Bali atau permainan gamelan gaya Bali memberikan pengaruh atau saling memengaruhi daerah budaya di sekitarnya, misalnya pada musik tradisional masyarakat Banyuwangi serta musik tradisional masyarakat Lombok.
 Gamelan
 Jegog
 Genggong
 Silat Bali

Tari 

Seni tari Bali pada umumnya dapat dikategorikan menjadi tiga kelompok, yaitu wali atau seni tari pertunjukan sakral, bebali atau seni tari pertunjukan untuk upacara dan juga untuk pengunjung dan balih-balihan atau seni tari untuk hiburan pengunjung.

Pakar seni tari Bali I Made Bandem pada awal tahun 1980-an pernah menggolongkan tari-tarian Bali tersebut; antara lain yang tergolong ke dalam wali misalnya Berutuk, Sang Hyang Dedari, Rejang dan Baris Gede, bebali antara lain ialah Gambuh, Topeng Pajegan dan Wayang Wong, sedangkan balih-balihan antara lain ialah Legong, Parwa, Arja, Prembon dan Joged serta berbagai koreografi tari modern lainnya.

Salah satu tarian yang sangat populer bagi para wisatawan ialah Tari Kecak dan Tari Pendet. Sekitar tahun 1930-an, Wayan Limbak bekerja sama dengan pelukis Jerman Walter Spies menciptakan tari Kecak berdasarkan tradisi Sang Hyang dan bagian-bagian kisah Ramayana. Wayan Limbak memopulerkan tari ini saat berkeliling dunia bersama rombongan penari Bali-nya.

Tarian wali 
 Sang Hyang Dedari
 Sang Hyang Jaran
 Tari Rejang
 Tari Baris

Tarian bebali 
 Tari Topeng
 Gambuh

Tarian balih-balihan 
 Tari Legong
 Arja
 Joged Bumbung
 Drama Gong
 Barong
 Tari Pendet
 Tari Kecak
 Calon Arang
 Tari Janger
 Tari Tenun

Pakaian daerah 
Pakaian daerah Bali sesungguhnya sangat bervariasi, meskipun secara selintas kelihatannya sama. Masing-masing daerah di Bali mempunyai ciri khas simbolik dan ornamen, berdasarkan kegiatan/upacara, jenis kelamin dan umur penggunanya. Status sosial dan ekonomi seseorang dapat diketahui berdasarkan corak busana dan ornamen perhiasan yang dipakainya.

Pria 

Busana tradisional pria umumnya terdiri dari:
 Udeng (ikat kepala)
 Kain kampuh
 Umpal (selendang pengikat)
 Kain wastra (kemben)
 Sabuk
 Keris
 Beragam ornamen perhiasan

Sering pula dikenakan baju kemeja, jas dan alas kaki sebagai pelengkap.

Wanita 

Busana tradisional wanita umumnya terdiri dari:
 Gelung (sanggul)
 Sesenteng (kemben songket)
 Kain wastra
 Sabuk prada (stagen), membelit pinggul dan dada
 Selendang songket bahu ke bawah
 Kain tapih atau sinjang, di sebelah dalam
 Beragam 

პრეზიდენტი — ტიტული, რომელსაც ატარებენ ქვეყნების, ორგანიზაციების, კომპანიების, სასწავლებლების პირველი პირები. ეტიმოლოგიურად პრეზიდენტი ნიშნავს პიროვნებას, რომელიც თავმჯდომარის ფუნქციას ასრულებს (ლათინურად: prae (წინ, თავში) + sedere (ჯდომა)). 

მისი თავდაპირველი მნიშვნელობა იყო შეხვედრების, ცერემონიების გაძღოლა, ამჟამად ის უპირატესად თანამდებობის პირთან ასოცირდება, რომელსაც აღმასრულებელი ხელისუფლება აქვს. პრეზიდენტის, როგორც სახელმწიფოს მეთაურის, ძალაუფლების ხარისხი ვარირებს ქვეყნიდან ქვეყანაში, ზოგიერთ ქვეყანაში მას დიდ ძალაუფლება აქვს მინიჭებული, მაგალითად აშშ-ში, საფრანგეთში, ზოგიერთში კი ნომინალური (გერმანია, იტალია).

იხილეთ აგრეთვე 

 საქართველოს პრეზიდენტი
 აზერბაიჯანის პრეზიდენტი
 აშშ-ის პრეზიდენტი
 გერმანიის პრეზიდენტი
 ესტონეთის პრეზიდენტი
 თურქეთის პრეზიდენტი
 ირანის პრეზიდენტი
 ისრაელის პრეზიდენტი
 ნიკარაგუის პრეზიდენტი
 რუსეთის პრეზიდენტი
 საფრანგეთის პრეზიდენტი
 სომხეთის პრეზიდენტი
 უკრაინის პრეზიდენტი
 ევროკომისიის პრეზიდენტი
 ევროპის პარლამენტის პრეზიდენტები

რესურსები ინტერნეტში
 

წოდებები

# Standalone Application with Briefcase

[Briefcase](https://briefcase.beeware.org/) is a tool for packaging Python
projects as standalone native applications. It can produce installers and
executables for macOS, Windows, and Linux that do not require the user to
install Python or any dependencies.

- Produces platform-native installers (``.pkg`` on macOS, ``.msi`` on
    Windows, ``.deb``/``.rpm`` on Linux).
- Bundles a Python interpreter and all dependencies.
- Supports passing command line arguments to the app.

This page outlines the basics of packaging a Click application with
Briefcase. Be sure to read its
[documentation](https://briefcase.beeware.org/en/stable/how-to/building/cli-apps/)
and use ``briefcase --help`` to understand what features are available.

## Installation

Install Briefcase in the virtual environment:

```console
pip install briefcase
```

## Configuration

Add a ``[tool.briefcase]`` section and a
``[tool.briefcase.app.<app-name>]`` section to ``pyproject.toml``.
Set ``console_app = true`` so Briefcase treats the project as a command
line application rather than a GUI application.

Given a Click application with the following project structure:

```text
hello-cli/
    src/
        hello_cli/
            __init__.py
            app.py
    LICENSE
    pyproject.toml
```

Where ``app.py`` contains a Click command:

```python
import click

@click.command()
@click.argument("name", default="World")
@click.option("--count", default=1, help="Number of times to greet.")
def main(name, count):
    """Greet someone by NAME (default: World)."""
    for _ in range(count):
        click.echo(f"Hello, {name}!")
```

Add the following Briefcase configuration to ``pyproject.toml``:

```toml
[tool.briefcase]
project_name = "Hello CLI"
bundle = "com.example"
version = "0.0.1"
url = "https://example.com/hello-cli"
license.file = "LICENSE"
author = "Your Name"
author_email = "you@example.com"

[tool.briefcase.app.hello-cli]
formal_name = "Hello CLI"
description = "My first application"
long_description = """More details about the app should go here.
"""
sources = [
    "src/hello_cli",
]
console_app = true
requires = [
    "click",
]
```

The key settings are:

- ``console_app = true`` -- tells Briefcase this is a terminal
    application, not a GUI.
- ``sources`` -- the list of source packages to include.
- ``requires`` -- the Python dependencies to bundle (Click and any other
    libraries the project needs).

## Entry Point

Briefcase launches the application by running the package with
``python -m <package>``, so a ``__main__.py`` file **must** exist in the
package. Without it, Briefcase will not be able to start the application.

Create ``__main__.py`` in the package directory and call the Click
command:

```python
from hello_cli.app import main

if __name__ == "__main__":
    main()
```

## Running

Use ``briefcase dev`` to run the application directly from the source
tree. Pass command line arguments after ``--``:

```console
$ briefcase dev -- World
Hello, World!
$ briefcase dev -- World --count 2
Hello, World!
Hello, World!
```

## Building and Packaging

To create a distributable executable, run the following commands:

```console
briefcase create
briefcase build
briefcase package
```

``briefcase create`` downloads a Python interpreter and installs
dependencies into an isolated app bundle. ``briefcase build`` compiles
the app, and ``briefcase package`` produces the final platform installer.

On macOS, this produces a ``.pkg`` installer. On Windows, it produces a
``.msi`` installer. On Linux, it produces a system package (``.deb``,
``.rpm``, etc.) for the current distribution.

Once installed, users can run the application directly from the terminal:

```console
$ hello-cli World
Hello, World!
$ hello-cli World --count 2
Hello, World!
Hello, World!
```

<a id="top"></a>
# Why do we need yet another C++ test framework?

Good question. For C++ there are quite a number of established frameworks,
including (but not limited to),
[Google Test](http://code.google.com/p/googletest/),
[Boost.Test](http://www.boost.org/doc/libs/1_49_0/libs/test/doc/html/index.html),
[CppUnit](http://sourceforge.net/apps/mediawiki/cppunit/index.php?title=Main_Page),
[Cute](http://www.cute-test.com), and
[many, many more](http://en.wikipedia.org/wiki/List_of_unit_testing_frameworks#C.2B.2B).

So what does Catch2 bring to the party that differentiates it from these? Apart from the catchy name, of course.


## Key Features

* Quick and easy to get started. Just download two files, add them into your project and you're away.
* No external dependencies. As long as you can compile C++14 and have the C++ standard library available.
* Write test cases as, self-registering, functions (or methods, if you prefer).
* Divide test cases into sections, each of which is run in isolation (eliminates the need for fixtures).
* Use BDD-style Given-When-Then sections as well as traditional unit test cases.
* Only one core assertion macro for comparisons. Standard C/C++ operators are used for the comparison - yet the full expression is decomposed and lhs and rhs values are logged.
* Tests are named using free-form strings - no more couching names in legal identifiers.


## Other core features

* Tests can be tagged for easily running ad-hoc groups of tests.
* Failures can (optionally) break into the debugger on common platforms.
* Output is through modular reporter objects. Basic textual and XML reporters are included. Custom reporters can easily be added.
* JUnit xml output is supported for integration with third-party tools, such as CI servers.
* A default main() function is provided, but you can supply your own for complete control (e.g. integration into your own test runner GUI).
* A command line parser is provided and can still be used if you choose to provide your own main() function.
* Alternative assertion macro(s) report failures but don't abort the test case
* Good set of facilities for floating point comparisons (`Catch::Approx` and full set of matchers)
* Internal and friendly macros are isolated so name clashes can be managed
* Data generators (data driven test support)
* Hamcrest-style Matchers for testing complex properties
* Microbenchmarking support


## Who else is using Catch2?

A whole lot of people. According to [the 2022 JetBrains C++ ecosystem survey](https://www.jetbrains.com/lp/devecosystem-2022/cpp/#Which-unit-testing-frameworks-do-you-regularly-use),
about 12% of C++ programmers use Catch2 for unit testing, making it the
second most popular unit testing framework.

You can also take a look at the (incomplete) list of [open source projects](opensource-users.md#top)
or the (very incomplete) list of [commercial users of Catch2](commercial-users.md#top)
for some idea on who else also uses Catch2.

---

See the [tutorial](tutorial.md#top) to get more of a taste of using
Catch2 in practice.

---

[Home](Readme.md#top)

Dr. Ing. h.c. F. Porsche AG, kısaca Porsche AG veya sadece Porsche (okunuşu: Porşe) 1947 yılında Ferdinand Porsche'nın oğlu Ferry Porsche tarafından Stuttgart'ta kurulmuş olan spor araba firmasıdır.

İlk modelleri 1948 yılında çıkan Porsche 356'dır. Ferdinand Porsche 356 tasarımını yaparken oğluna yardım etmiş ve 1951 yılında ölmüştür.

1963 yılında araba yarışlarında müthiş başarılar elde edecek Porsche 911'i piyasaya sunarlar. 6 silindirli, arkadan motorlu bir spor arabasıdır ve rallilerde de büyük başarılar kazanır.

Bu süre içerisinde Volkswagen ile yakınlaşılır.  Şirketin %30,9'u Volkswagen'e aittir. Birçok projede ortaklaşa çalışmalarda bulunurlar. (1969 VW-Porsche 914, 1976 Porsche 924 (Audi bazı parçaları kullanmıştır) ve 2002 Porsche Cayenne (motoru da başta olmak üzere birçok teknik aksamı ve ergonomik çizgileri Volkswagen Touareg'de kullanılmıştır). 2003 yılında Ferdinand Porsche'nin torunu, Ferdinand Piech Volkswagen'in CEO'su olarak bu iki şirketin "ailesel" anlamda birleşmesini sağlamıştır. Porsche, 1950-1963 yılları arasında Porsche Traktör adıyla traktör, 1987-1989 yılları arasında uçak motorları üretmiştir.

Porsche LeMans'ı 16 kez kazanmış, Formula 1'de McLaren'in motorunu yaratmış, Paris Dakar Rallisi'nin de zirvedeki isimlerinden biri olmuştur.

Volkswagen AG, Porsche'nin %52,2 hissesini satın almıştır.

Seat, Daewoo ve Subaru başta olmak üzere birçok otomotiv firması danışman olarak Porsche firmasıyla anlaşma yapmışlardır.

Modelleri

Hâlen üretilmekte olan modeller
 Porsche Taycan (2019-Günümüz)
 Porsche 918 Spyder (2013-Günümüz)
 Porsche Boxster (1996-Günümüz)
 Porsche Cayman (2006-Günümüz)
 Porsche 911 (1964-Günümüz)
 Porsche Panamera (2010-Günümüz)
 Porsche Cayenne (2004-Günümüz)
 Porsche 911 GT3 (1998-Günümüz)
Üretimden Kaldırılmış Modeller
 Porsche 356 (1948-1965)
 Porsche 550 Spyder (1953-1957)
 Porsche 912 (1965-1969)
 Porsche 914 (1969-1975)
 Porsche 924 (1976-1988)
 Porsche 928 (1978-1995)
 Porsche 944 (1982-1991)
 Porsche 959 (1986-1988)
 Porsche 968 (1992-1995)
 Porsche Carrera GT (2004-2006)

Yarış modelleri
 Porsche 64
 Porsche 360 Cisitalia
 Porsche 550 Spyder
 Porsche 718
 Porsche 804
 Porsche 904
 Porsche 906
 Porsche 907
 Porsche 908
 Porsche 909 Bergspyder
 Porsche 910
 Porsche 911
 Porsche 911 GT1
 Porsche 911 GT2
 Porsche 911 GT3
 Porsche 914
 Porsche 917
 Porsche 918 RSR
 Porsche 934
 Porsche 935
 Porsche 936
 Porsche 924
 Porsche 944
 Porsche 956
 Porsche 959
 Porsche 961
 Porsche-March 89 P
 Porsche RS Spyder

Motor sporlarında Porsche 
 14 Üreticiler ve Takımlar Dünya şampiyonluğu (1964, 1969, 1970, 1971, 1976, 1977, 1978, 1979, 1982, 1983, 1984, 1985, 1986, 1994)
 8 Uzun Mesafe Dünya Şampiyonluğu
 3 IMSA Supercar-Series (1991, 1992, 1993)
 6 Alman Yarış Şampiyonluğu (1977, 1979, 1982, 1983, 1984, 1985)
 20 Avrupa Tırmanış Şampiyonluğu
 20 Daytona 24 Saat Şampiyonluğu (1968, 1970, 1971, 1973, 1975, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1989, 1991, 1995, 2003)
 15 IMSA Supercar-Race (ABD)
 16 Le Mans 24 Saat (1970, 1971, 1976, 1977, 1979, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1994, 1996, 1997, 1998)
 17 Sebring 12 Saat (1960, 1968, 1971, 1973, 1976, 1977, 1978, 1979, 1980, 1981, 1982, 1983, 1984, 1985, 1986, 1987, 1988)
 11 Targa Florio (1956, 1959, 1960, 1963, 1964, 1966, 1967, 1968, 1969, 1970, 1973)
 4 Rallye Monte Carlo (1968, 1969, 1970, 1978)
 2 Paris-Dakar Rallisi (1984, 1986)
 1 Formula 1 zaferi (1962 Fransa Grand Prix)

TAG-Porsche motorlu McLaren otomobilleri 
 3 Formula 1 Pilotlar Dünya Şampiyonluğu (1984, 1985, 1986)
 2 Formula 1 üreticiler Dünya Şampiyonluğu (1984, 1985)
 25 Formula 1 zaferi (1984, 12 galibiyet; 1985, 6 galibiyet; 1986, 4 galibiyet; 1987, 3 galibiyet)

Notlar

Dış bağlantılar 
 Resmî Porsche web sitesi (Birçok dilde)
 Porsche Türkiye

1947'de kurulan şirketler
Stuttgart
Baden-Württemberg'te ekonomi
Almanya merkezli otomotiv şirketleri
Otomobil markaları
Otomobil üreticileri
Traktör üreticileri
Volkswagen grubu
Alman markaları
Lüks markalar

# Advanced Groups and Context

```{currentmodule} click
```

In addition to the capabilities covered in the previous section, Groups have
more advanced capabilities that leverage the Context.

```{contents}
---
depth: 1
local: true
---
```

## Callback Invocation

For a regular command, the callback is executed whenever the command runs.
If the script is the only command, it will always fire (unless a parameter
callback prevents it.  This for instance happens if someone passes
`--help` to the script).

For groups, the situation looks different. In this case, the callback fires
whenever a subcommand fires.  What this means in practice is that an outer
command runs when an inner command runs:

```{eval-rst}
.. click:example::

    @click.group()
    @click.option('--debug/--no-debug', default=False)
    def cli(debug):
        click.echo(f"Debug mode is {'on' if debug else 'off'}")

    @cli.command()  # @cli, not @click!
    def sync():
        click.echo('Syncing')

Here is what this looks like:

.. click:run::

    invoke(cli, prog_name='tool.py')
    println()
    invoke(cli, prog_name='tool.py', args=['--debug', 'sync'])
```

## Nested Handling and Contexts

As you can see from the earlier example, the basic command group accepts a
debug argument which is passed to its callback, but not to the sync
command itself.  The sync command only accepts its own arguments.

This allows tools to act completely independent of each other, but how
does one command talk to a nested one?  The answer to this is the
{class}`Context`.

Each time a command is invoked, a new context is created and linked with the
parent context.  Normally, you can't see these contexts, but they are
there.  Contexts are passed to parameter callbacks together with the
value automatically.  Commands can also ask for the context to be passed
by marking themselves with the {func}`pass_context` decorator.  In that
case, the context is passed as first argument.

The context can also carry a program specified object that can be
used for the program's purposes.  What this means is that you can build a
script like this:

```{eval-rst}
.. click:example::

    @click.group()
    @click.option('--debug/--no-debug', default=False)
    @click.pass_context
    def cli(ctx, debug):
        # ensure that ctx.obj exists and is a dict (in case `cli()` is called
        # by means other than the `if` block below)
        ctx.ensure_object(dict)

        ctx.obj['DEBUG'] = debug

    @cli.command()
    @click.pass_context
    def sync(ctx):
        click.echo(f"Debug is {'on' if ctx.obj['DEBUG'] else 'off'}")

    if __name__ == '__main__':
        cli(obj={})
```

If the object is provided, each context will pass the object onwards to
its children, but at any level a context's object can be overridden.  To
reach to a parent, `context.parent` can be used.

In addition to that, instead of passing an object down, nothing stops the
application from modifying global state.  For instance, you could just flip
a global `DEBUG` variable and be done with it.

## Decorating Commands

As you have seen in the earlier example, a decorator can change how a
command is invoked.  What actually happens behind the scenes is that
callbacks are always invoked through the {meth}`Context.invoke` method
which automatically invokes a command correctly (by either passing the
context or not).

This is very useful when you want to write custom decorators.  For
instance, a common pattern would be to configure an object representing
state and then storing it on the context and then to use a custom
decorator to find the most recent object of this sort and pass it as first
argument.

For instance, the {func}`pass_obj` decorator can be implemented like this:

```{eval-rst}
.. click:example::

    from functools import update_wrapper

    def pass_obj(f):
        @click.pass_context
        def new_func(ctx, *args, **kwargs):
            return ctx.invoke(f, ctx.obj, *args, **kwargs)
        return update_wrapper(new_func, f)
```

The {meth}`Context.invoke` command will automatically invoke the function
in the correct way, so the function will either be called with`f(ctx,
obj)` or `f(obj)` depending on whether or not it itself is decorated with
{func}`pass_context`.

This is a very powerful concept that can be used to build very complex
nested applications; see {ref}`complex-guide` for more information.

(command-chaining)=

## Command Chaining

It is useful to invoke more than one subcommand in one call. For example,
`my-app validate build upload` would invoke `validate`, then `build`, then
`upload`. To implement this, pass `chain=True` when creating a group.

```{eval-rst}
.. click:example::

    @click.group(chain=True)
    def cli():
        pass

    @cli.command('validate')
    def validate():
        click.echo('validate')

    @cli.command('build')
    def build():
        click.echo('build')

You can invoke it like this:

.. click:run::

    invoke(cli, prog_name='my-app', args=['validate', 'build'])
```

When using chaining, there are a few restrictions:

- Only the last command may use `nargs=-1` on an argument, otherwise the
  parser will not be able to find further commands.
- It is not possible to nest groups below a chain group.
- On the command line, options must be specified before arguments for each
  command in the chain.
- The {attr}`Context.invoked_subcommand` attribute will be `'*'` because the
  parser doesn't know the full list of commands that will run yet.

(command-pipelines)=

## Command Pipelines

When using chaining, a common pattern is to have each command process the
result of the previous command.

A straightforward way to do this is to use {func}`make_pass_decorator` to pass
a context object to each command, and store and read the data on that object.

```{eval-rst}
.. click:example::

    pass_ns = click.make_pass_decorator(dict, ensure=True)

    @click.group(chain=True)
    @click.argument("name")
    @pass_ns
    def cli(ns, name):
        ns["name"] = name

    @cli.command
    @pass_ns
    def lower(ns):
        ns["name"] = ns["name"].lower()

    @cli.command
    @pass_ns
    def show(ns):
        click.echo(ns["name"])

.. click:run::

    invoke(cli, prog_name="process", args=["Click", "show", "lower", "show"])
```

Another way to do this is to collect data returned by each command, then process
it at the end of the chain. Use the group's {meth}`~Group.result_callback`
decorator to register a function that is called after the chain is finished. It
is passed the list of return values as well as any parameters registered on the
group.

A command can return anything, including a function. Here's an example of that,
where each subcommand creates a function that processes the input, then the
result callback calls each function. The command takes a file, processes each
line, then outputs it. If no subcommands are given, it outputs the contents
of the file unchanged.

```python
@click.group(chain=True, invoke_without_command=True)
@click.argument("fin", type=click.File("r"))
def cli(fin):
    pass

@cli.result_callback()
def process_pipeline(processors, fin):
    iterator = (x.rstrip("\r\n") for x in input)

    for processor in processors:
        iterator = processor(iterator)

    for item in iterator:
        click.echo(item)

@cli.command("upper")
def make_uppercase():
    def processor(iterator):
        for line in iterator:
            yield line.upper()
    return processor

@cli.command("lower")
def make_lowercase():
    def processor(iterator):
        for line in iterator:
            yield line.lower()
    return processor

@cli.command("strip")
def make_strip():
    def processor(iterator):
        for line in iterator:
            yield line.strip()
    return processor
```

That's a lot in one go, so let's go through it step by step.

1. The first thing is to make a {func}`group` that is chainable.  In
   addition to that we also instruct Click to invoke even if no
   subcommand is defined.  If this would not be done, then invoking an
   empty pipeline would produce the help page instead of running the
   result callbacks.
2. The next thing we do is to register a result callback on our group.
   This callback will be invoked with an argument which is the list of
   all return values of all subcommands and then the same keyword
   parameters as our group itself.  This means we can access the input
   file easily there without having to use the context object.
3. In this result callback we create an iterator of all the lines in the
   input file and then pass this iterator through all the returned
   callbacks from all subcommands and finally we print all lines to
   stdout.

After that point we can register as many subcommands as we want and each
subcommand can return a processor function to modify the stream of lines.

One important thing of note is that Click shuts down the context after
each callback has been run.  This means that for instance file types
cannot be accessed in the `processor` functions as the files will already
be closed there.  This limitation is unlikely to change because it would
make resource handling much more complicated.  For such it's recommended
to not use the file type and manually open the file through
{func}`open_file`.

For a more complex example that also improves upon handling of the pipelines,
see the [imagepipe example](https://github.com/pallets/click/tree/main/examples/imagepipe)
in the Click repository. It implements a pipeline based image editing tool
that has a nice internal structure.

## Overriding Defaults

By default, the default value for a parameter is pulled from the
`default` flag that is provided when it's defined, but that's not the
only place defaults can be loaded from.  The other place is the
{attr}`Context.default_map` (a dictionary) on the context.  This allows
defaults to be loaded from a configuration file to override the regular
defaults.

This is useful if you plug in some commands from another package but
you're not satisfied with the defaults.

The default map can be nested arbitrarily for each subcommand:

```python

    default_map = {
        "debug": True,  # default for a top level option
        "runserver": {"port": 5000}  # default for a subcommand
    }
```

The default map can be provided when the script is invoked, or
overridden at any point by commands. For instance, a top-level command
could load the defaults from a configuration file.

Example usage:

```{eval-rst}
.. click:example::

    import click

    @click.group()
    def cli():
        pass

    @cli.command()
    @click.option('--port', default=8000)
    def runserver(port):
        click.echo(f"Serving on http://127.0.0.1:{port}/")

    if __name__ == '__main__':
        cli(default_map={
            'runserver': {
                'port': 5000
            }
        })

And in action:

.. click:run::

    invoke(cli, prog_name='cli', args=['runserver'], default_map={
        'runserver': {
            'port': 5000
        }
    })
```

### Multi-value parameters

When a `default_map` value is a string for a parameter with `nargs > 1` or a
{class}`Tuple` type, the string is split automatically, the same way an
environment variable would be. By default, values are split on whitespace. See
[Multiple Options from Environment
Values](options.md#multiple-options-from-environment-values) for details on
splitting behavior.

```python
default_map = {
    "draw": {
        "point": "3 4",  # split into ("3", "4") for nargs=2
        "color": "red",  # passed as-is for nargs=1
    }
}
```

You can also pass an already-structured tuple or list, which will be used as-is
without splitting:

```python
default_map = {
    "draw": {
        "point": (3, 4),  # used directly
    }
}
```

## Context Defaults

```{versionadded} 2.0
```

Starting with Click 2.0 you can override defaults for contexts not just
when calling your script, but also in the decorator that declares a
command.  For instance given the previous example which defines a custom
`default_map` this can also be accomplished in the decorator now.

This example does the same as the previous example:

```{eval-rst}
.. click:example::

    import click

    CONTEXT_SETTINGS = dict(
        default_map={'runserver': {'port': 5000}}
    )

    @click.group(context_settings=CONTEXT_SETTINGS)
    def cli():
        pass

    @cli.command()
    @click.option('--port', default=8000)
    def runserver(port):
        click.echo(f"Serving on http://127.0.0.1:{port}/")

    if __name__ == '__main__':
        cli()

And again the example in action:

.. click:run::

    invoke(cli, prog_name='cli', args=['runserver'])
```

## Command Return Values

```{versionadded} 3.0
```

One of the new introductions in Click 3.0 is the full support for return
values from command callbacks.  This enables a whole range of features
that were previously hard to implement.

In essence any command callback can now return a value.  This return value
is bubbled to certain receivers.  One usecase for this has already been
show in the example of {ref}`command-chaining` where it has been
demonstrated that chained groups can have callbacks that process
all return values.

When working with command return values in Click, this is what you need to
know:

- The return value of a command callback is generally returned from the
  {meth}`Command.invoke` method.  The exception to this rule has to
  do with {class}`Group`s:

  - In a group the return value is generally the return value of the
    subcommand invoked.  The only exception to this rule is that the
    return value is the return value of the group callback if it's
    invoked without arguments and `invoke_without_command` is enabled.
  - If a group is set up for chaining then the return value is a list
    of all subcommands' results.
  - Return values of groups can be processed through a
    {attr}`Group.result_callback`.  This is invoked with the
    list of all return values in chain mode, or the single return
    value in case of non chained commands.

- The return value is bubbled through from the {meth}`Context.invoke`
  and {meth}`Context.forward` methods.  This is useful in situations
  where you internally want to call into another command.

- Click does not have any hard requirements for the return values and
  does not use them itself.  This allows return values to be used for
  custom decorators or workflows (like in the command chaining
  example).

- When a Click script is invoked as command line application (through
  {meth}`Command.main`) the return value is ignored unless the
  `standalone_mode` is disabled in which case it's bubbled through.