text:
project_path: /web/fundamentals/_project.yaml
book_path: /web/fundamentals/_book.yaml
description: Métricas de desempenho centradas no usuário

{# wf_updated_on: 2019-02-06 #}
{# wf_published_on: 2017-06-01 #}
{# wf_tags: performance #}
{# wf_blink_components: Blink>PerformanceAPIs #}

{% include "web/tools/chrome-devtools/_shared/styles.html" %}

# Métricas de desempenho centradas no usuário {: .page-title }

{% include "web/_shared/contributors/philipwalton.html" %}

Você já deve ter ouvidos diversas vezes que o desempenho é importante e que é
crucial que seus aplicativos da Web sejam rápidos.

Mas ao tentar responder à pergunta *meu aplicativo é rápido?*, você perceberá que
rápido é um termo vago. O que queremos dizer exatamente com rápido? Em que
contexto? E rápido pra quem?

  Note: caso você prefira assistir a um vídeo em vez de ler um artigo,
 tratei deste assunto na Google I/O 2017 com minha colega
 Shubhie Panicker.

Ao falarmos de desempenho, a precisão é importante. Assim não criamos
mal-entendidos nem espalhamos mitos que podem, às vezes, levar desenvolvedores bem-intencionados
a otimizações erradas—que, em última instância, são mais prejudiciais
do que benéficas à experiência do usuário.

Para dar um exemplo específico, é comum hoje em dia ouvir as pessoas dizerem algo
como: __*Testei meu aplicativo e ele carrega em X.XX segundos*__.

O problema dessa afirmação *não* é que ela seja falsa, é que se trata
de uma representação equivocada da realidade. Os tempos de carregamento variam drasticamente de usuário para usuário,
dependendo das capacidades do dispositivo e das condições de rede. Apresentar tempos
de carregamento como um número único ignora os usuários que tiveram carregamentos muito mais lentos.

Na verdade, o tempo de carregamento do aplicativo é a junção de todos os tempos de carregamento de cada
usuário individual. O único jeito de representar completamente essa informação é com uma distribuição,
como no histograma abaixo:

Os números ao longo do eixo X mostram os tempos de carregamento, e a altura das barras no
eixo Y mostram o número relativo de usuários que tiveram um tempo de carregamento naquele intervalo
de tempo específico. Como esse gráfico mostra, enquanto o maior segmento de usuários
teve tempos de carregamento inferiores a um ou dois segundos, muitos deles ainda tiveram tempos bem
mais longos.

O outro motivo que faz da afirmação "meu site carrega em X.XX segundos" um mito é que o carregamento não é um
momento único no tempo—, mas uma experiência que nenhuma métrica pode capturar
completamente. Existem diversos momentos durante a experiência de carregamento que podem afetar
a percepção do usuário sobre ela ser "rápida". Se você focar em apenas um desses momentos, poderá
ignorar experiências ruins que acontecem no restante do tempo.

Por exemplo, considere um aplicativo que otimiza a renderização inicial rápida,
fornecendo conteúdo para o usuário imediatamente. Se esse aplicativo carregar um pacote
JavaScript grande, que leva vários segundos para analisar e executar, o conteúdo
na página não será interativo até que o JavaScript funcione. Se o usuário
conseguir ver um link na página, mas não puder clicar nele, ou ainda se puder ver uma caixa de texto
e não conseguir digitar, provavelmente não se importará com a rapidez de renderização da página.

Então, em vez de medir o carregamento com apenas uma métrica, deveríamos fazer a medição de
cada momento que pode ter efeito sobre a *percepção* de carregamento do usuário
ao longo da experiência.

Um segundo exemplo de mito de desempenho é que __*o desempenho só preocupa
durante o tempo de carregamento*__.

Nós, como equipe, somos responsáveis por esse equívoco, e ele torna-se ainda mais significativo porque
a maioria das ferramentas de desempenho medem *somente* o carregamento.

Mas a verdade é que um desempenho fraco pode ocorrer a qualquer momento, não apenas durante o
carregamento. Aplicativos que não respondem rapidamente a toques ou cliques e aqueles que não
rolam ou animam de maneira suave podem ser tão ruins quanto aplicativos com carregamento lento. Os usuários
preocupam-se com a experiência completa e nós, os desenvolvedores, deveríamos fazer o mesmo.

Um tema comum em todos esses equívocos com relação ao desempenho é que eles focam em
coisas que têm pouco ou nada a ver com a experiência do usuário. Da mesma forma,
as métricas de desempenho tradicionais como o
tempo de [carregamento](https://developer.mozilla.org/en-US/docs/Web/Events/load) ou o tempo de
[DOMContentLoaded](https://developer.mozilla.org/en-US/docs/Web/Events/DOMContentLoaded)
não são totalmente confiáveis, uma vez que sua ocorrência pode ou não corresponder
ao momento em que o usuário acha que o aplicativo está carregado.

Para evitar a repetição desse erro, precisamos responder a estas
perguntas:

1. Quais métricas medem de maneira mais precisa o desempenho percebido por uma pessoa?
2. Como medimos essas métricas em nossos usuários atuais?
3. Como interpretamos nossas medidas para determinar se um aplicativo é "rápido"?
4. Depois de entender o desempenho real do aplicativo para o usuário, o que fazemos para impedir
   regressões e termos a oportunidade de melhorar o desempenho no futuro?

## Métricas de desempenho centradas no usuário

Quando um usuário navega em uma página da Web, ele normalmente procura por feedback
visual que confirme que tudo funcionará da forma esperada.

   A página está funcionando?
   O início da navegação foi bem-sucedido? O servidor respondeu?

   A página é útil?
   Ela tem conteúdo renderizado suficiente que permita que os usuários interajam?

   A página pode ser usada?
   Os usuários podem interagir com a página ou ela ainda está em processo de carregamento?

   A página é agradável?
   As interações são fluidas e naturais, sem lentidão e instabilidade?

Para compreender quando uma página oferece esse feedback aos usuários, definimos
várias métricas novas:

### Primeira exibição e primeira exibição de conteúdo

A [Paint Timing API](https://github.com/WICG/paint-timing) define duas
métricas: a *primeira exibição* (FP, na sigla em inglês) e a *primeira exibição de conteúdo* (FCP, na sigla em inglês). Essas métricas
marcam os pontos, imediatamente após a navegação, em que o navegador renderiza pixels
na tela. Isso é importante para o usuário porque responde à pergunta:
*A página está funcionando?

A principal diferença entre as duas métricas é que a FP marca o momento em que o
navegador renderiza *algo* que é visualmente diferente do que estava na
tela antes da navegação. Por outro lado, a FCP é o momento em que o navegador
renderiza a primeira parte do conteúdo do DOM que pode ser texto, imagem, SVG
ou até mesmo um elemento `<canvas>`.

### Primeira exibição significativa e tempo de elemento principal

A primeira exibição significativa (FMP, na sigla em inglês) é a métrica que responde à pergunta: "A página é
útil?". Embora o conceito de "útil" seja muito difícil de especificar de uma forma que
se aplique genericamente a todas as páginas da Web (e, portanto, não há especificação), é muito
fácil para os desenvolvedores Web saber quais partes das páginas serão
mais úteis aos usuários.

Essas "partes mais importantes" de uma página da Web geralmente são chamadas de *elementos
principais*. Na página de exibição do YouTube, por exemplo, o elemento principal é o
vídeo principal. No Twitter, provavelmente seja os indicadores de notificação e o primeiro
tuíte. Em um aplicativo de meteorologia, é a previsão do tempo para o local especificado. E em um site de
notícias, normalmente é a história principal e a imagem em destaque.

Páginas da Web quase sempre têm partes que são mais importantes do que outras. Se as
partes mais importantes de uma página são carregadas rapidamente, o usuário pode nem mesmo perceber que
o restante ainda não carregou.

### Tarefas longas

Os navegadores respondem aos comandos do usuário adicionando tarefas que são executadas uma por uma em uma fila
do thread principal. É aí também que o navegador executa o
JavaScript do aplicativo. Nesse sentido, o navegador tem thread único.

Em alguns casos, essas tarefas podem levar muito tempo para serem executadas. Se isso ocorrer, o
thread principal será bloqueado e todas as outras tarefas na fila precisarão esperar.

Para o usuário, isso aparece como lentidão ou instabilidade. Hoje em dia, essa é uma das maiores fontes de
experiências ruins na Internet.

A [Long Tasks API](https://w3c.github.io/longtasks/) identifica qualquer tarefa
maior do que 50 milissegundos como potencialmente problemática e expõe essas
tarefas para o desenvolvedor do aplicativo. O tempo de 50 milissegundos foi escolhido para que os aplicativos
pudessem atender às [diretrizes RAIL](/web/fundamentals/performance/rail) de
resposta ao comando do usuário em 100 ms.

### Tempo para interação da página

A métrica *Tempo para interação da página* (TTI, na sigla em inglês) marca o ponto no qual o aplicativo
está visualmente renderizado e capaz de responder de forma confiável ao comando do usuário. Um
aplicativo pode não conseguir responder ao comando do usuário por algumas razões:

* O JavaScript necessário para fazer os componentes da página funcionarem ainda não foi
  carregado.
* Tarefas longas estão bloqueando o thread principal (como descrito na última
 seção).

A métrica TTI identifica o ponto no qual o JavaScript inicial da página está
carregado e o thread principal está ocioso (sem tarefas longas).

### Mapeamento de métricas para a experiência do usuário

Voltando às perguntas que identificamos como as mais
importantes para a experiência do usuário, esta tabela ilustra como cada uma das métricas que
acabamos de listar é mapeada para a experiência que esperamos otimizar:

    A experiência
    A métrica

    A página está funcionando?
    Primeira exibição (FP)/Primeira exibição de conteúdo (FCP)

    A página é útil?
    Primeira exibição significativa (FMP)/Tempo de elemento principal

    A página pode ser usada?
    Tempo para interação da página (TTI)

    A página é agradável?
    Tarefas longas (tecnicamente, a falta de tarefas longas)

E estas capturas de tela de uma linha do tempo de carregamento podem ajudar a visualizar melhor onde
essas métricas se encaixam na experiência de carregamento:

A próxima seção mostra em detalhes como medir essas métricas em dispositivos de usuários reais.

## Medição de métricas em dispositivos de usuários reais

Um dos principais motivos pelos quais historicamente otimizamos com base em métricas como carregamento e
`DOMContentLoaded` é que eles são expostos como eventos no navegador e são fáceis de
medir em usuários reais.

Por outro lado, muitas outras métricas são historicamente muito difíceis de
medir. Por exemplo, este código é uma alternativa que frequentemente vemos os desenvolvedores usarem para detectar
tarefas longas:

```
(function detectLongFrame() {
  var lastFrameTime = Date.now();
  requestAnimationFrame(function() {
    var currentFrameTime = Date.now();

    if (currentFrameTime - lastFrameTime > 50) {
      // Report long frame here...
    }

    detectLongFrame(currentFrameTime);
  });
}());
```

Esse código inicia um loop infinito de `requestAnimationFrame` e registra o tempo
em cada iteração. Se o tempo atual for maior que 50 milissegundos após o
tempo anterior, o código pressupõe que foi resultado de uma tarefa longa. Embora esse código
funcione em geral, ele tem muitos pontos negativos:

* Ele adiciona sobrecarga a cada frame.
* Ele evita bloqueios ociosos.
* É péssimo para a duração da bateria.

A regra mais importante do código de medição do desempenho é que ele não deve
piorar o desempenho.

Serviços como o [Lighthouse](/web/tools/lighthouse/) e o [Web Page
Test](https://www.webpagetest.org/) oferecem algumas dessas novas métricas há
algum tempo (e são, em geral, ótimas ferramentas para teste de desempenho em
recursos antes de lançá-los), mas não são executados nos
dispositivos dos usuários e não representam a experiência de desempenho real deles.

Felizmente, com a introdução de algumas novas APIs de navegadores, a medição dessas métricas em
dispositivos reais finalmente é possível sem precisar recorrer a várias soluções alternativas que podem
piorar o desempenho.

Estas novas APIs são
[`PerformanceObserver`](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceObserver),
[`PerformanceEntry`](https://developer.mozilla.org/en-US/docs/Web/API/PerformanceEntry)
e
[`DOMHighResTimeStamp`](https://developer.mozilla.org/en-US/docs/Web/API/DOMHighResTimeStamp).
Para exibir alguns códigos com essas novas APIs em ação, o seguinte exemplo de código
cria uma nova instância de `PerformanceObserver` e inscreve-se em notificações
sobre entradas de exibição (por exemplo, FP e FCP), bem como para qualquer tarefa longa que ocorrer:

```
const observer = new PerformanceObserver((list) => {
  for (const entry of list.getEntries()) {
    // `entry` is a PerformanceEntry instance.
    console.log(entry.entryType);
    console.log(entry.startTime); // DOMHighResTimeStamp
    console.log(entry.duration); // DOMHighResTimeStamp
  }
});

// Start observing the entry types you care about.
observer.observe({entryTypes: ['resource', 'paint']});
```

O que o `PerformanceObserver` nos oferece e que nunca tivemos antes é a habilidade de
se inscrever em eventos de desempenho conforme eles acontecem, além de responder de
forma assíncrona. Isso substitui a antiga interface
[PerformanceTiming](https://www.w3.org/TR/navigation-timing/#sec-navigation-timing-interface)
, que frequentemente precisava pesquisar para ver quando os dados
estavam disponíveis.

### Rastreamento de FP/FCP

Quando você tiver os dados de um evento de desempenho específico, pode enviá-los para
qualquer serviço de análise para capturar a métrica do usuário atual.
Ao usar o Google Analytics, por exemplo, você pode rastrear os tempos de primeira exibição da
seguinte forma:

```
<head>
  <!-- Add the async Google Analytics snippet first. -->
  <script>
  window.ga=window.ga||function(){(ga.q=ga.q||[]).push(arguments)};ga.l=+new Date;
  ga('create', 'UA-XXXXX-Y', 'auto');
  ga('send', 'pageview');
  </script>
  <script async src='https://www.google-analytics.com/analytics.js'></script>

  <!-- Register the PerformanceObserver to track paint timing. -->
  <script>
  const observer = new PerformanceObserver((list) => {
    for (const entry of list.getEntries()) {
      // `name` will be either 'first-paint' or 'first-contentful-paint'.
      const metricName = entry.name;
      const time = Math.round(entry.startTime + entry.duration);

      ga('send', 'event', {
        eventCategory: 'Performance Metrics',
        eventAction: metricName,
        eventValue: time,
        nonInteraction: true,
      });
    }
  });
  observer.observe({entryTypes: ['paint']});
  </script>

  <!-- Include any stylesheets after creating the PerformanceObserver. -->
  <link rel="stylesheet" href="...">
</head>
```

Importante: você deve verificar se o PerformanceObserver
  está registrado no <head> do documento
 antes de qualquer folha de estilo para que ele seja executado antes da FP/FCP.

Isso não será mais necessário quando o Level 2 da especificação do Performance Observer
  for implementado, já que ele apresenta uma buffered sinalização que permite acessar entradas
 de desempenho enfileiradas antes do PerformanceObserver
  que está sendo criado.

### Rastreamento de FMP usando elementos principais

Depois de identificar quais elementos na página são os principais, você
deve rastrear o ponto no qual eles ficam visíveis aos usuários.

Não temos uma definição padronizada para FMP (e, portanto, nenhum tipo de
entrada de desempenho). Em parte, isso é devido à dificuldade em determinar
de forma genérica o que é ser "significativo" para todas as páginas.

No entanto, no contexto de uma única página ou de um único aplicativo, geralmente é
melhor considerar a FMP como sendo o momento em que seus elementos principais ficam visíveis na
tela.

Steve Souders tem um excelente artigo chamado [Métricas personalizadas e tempo
do usuário](https://speedcurve.com/blog/user-timing-and-custom-metrics/) que
aborda em detalhes muitas técnicas para usar APIs de desempenho do navegador para determinar
no código o momento em que vários tipos de mídia ficam visíveis.

### Rastreamento de TTI

Em longo prazo, esperamos ter uma métrica TTI padronizada e exposta no
navegador por meio do PerformanceObserver. Enquanto isso, desenvolvemos um polyfill
que pode ser usado para detectar TTI atualmente e funciona em qualquer navegador compatível com a
[Long Tasks API](https://w3c.github.io/longtasks/).

O polyfill expõe um método `getFirstConsistentlyInteractive()` que retorna
uma promessa que resolve com o valor TTI. Você pode rastrear o TTI usando o Google
Analytics da seguinte forma:

```
import ttiPolyfill from './path/to/tti-polyfill.js';

ttiPolyfill.getFirstConsistentlyInteractive().then((tti) => {
  ga('send', 'event', {
    eventCategory: 'Performance Metrics',
    eventAction: 'TTI',
    eventValue: tti,
    nonInteraction: true,
  });
});
```

O método `getFirstConsistentlyInteractive()` aceita uma configuração `startTime`
opcional, o que permite que você especifique um limite inferior antes do qual o aplicativo
não pode ser interativo. Por padrão, o polyfill usa
DOMContentLoaded como o horário de início, mas frequentemente é mais preciso usar
o momento em que os elementos principais ficam visíveis ou o ponto em que você
sabe que todos os seus listeners de evento foram adicionados.

Consulte a [documentação do polyfill de
TTI](https://github.com/GoogleChrome/tti-polyfill) para instruções
completas de instalação e uso.

  Note: assim como no caso da FMP, é muito difícil especificar uma definição de métrica TTI
 que funcione perfeitamente para todas as páginas da Web. A versão que
 implementamos no polyfill funcionará para a maioria dos aplicativos, mas é possível que não funcione
 para seu aplicativo específico. É importante testá-lo antes de
 contar com ele. Se desejar mais detalhes sobre a definição e implementação do TTI
, leia o
 documento de definição da métrica TTI.

### Rastreamento de tarefas longas

Mencionei acima que tarefas longas têm grandes chances de causar algum tipo de experiência
negativa do usuário (por exemplo, um gerenciador de eventos lento ou um frame perdido). É bom prestar
atenção à frequência com que isso acontece para que você possa se esforçar para minimizar o problema.

Para detectar tarefas longas no JavaScript, cria-se um novo `PerformanceObserver` e
observa-se as entradas do tipo `longtask`. Um bom recurso das entradas de tarefas longas é que
que elas contêm uma [property
attribution](https://w3c.github.io/longtasks/#sec-TaskAttributionTiming). Dessa forma,
você pode rastrear mais facilmente qual código causou a tarefa longa:

```
const observer = new PerformanceObserver((list) => {
  for (const entry of list.getEntries()) {
    ga('send', 'event', {
      eventCategory: 'Performance Metrics',
      eventAction: 'longtask',
      eventValue: Math.round(entry.startTime + entry.duration),
      eventLabel: JSON.stringify(entry.attribution),
    });
  }
});

observer.observe({entryTypes: ['longtask']});
```

A property attribution dirá a você qual contexto de frame foi responsável pela
tarefa longa, o que é útil para determinar se scripts iframe de terceiros estão
causando problemas. As versões futuras da especificação devem adicionar mais granularidade
e expor URL, linha e número de coluna do script. Isso será muito útil para ajudar a
determinar se seus próprios scripts estão causando lentidão.

### Rastreamento de latência de entrada

Tarefas longas que bloqueiam o thread principal podem evitar que os listeners de evento
sejam executados rapidamente. O [modelo de desempenho
RAIL](/web/fundamentals/performance/rail) ensina que, para que uma
interface do usuário pareça fluida, ela deve responder ao comando do usuário em 100 ms.
Se isso não acontecer, é importante saber o porquê.

Para detectar a latência de entrada no código, você pode comparar a data e a hora do evento com o
horário atual. Se a diferença for maior que 100 ms, você pode (e deve)
relatar.

```
const subscribeBtn = document.querySelector('#subscribe');

subscribeBtn.addEventListener('click', (event) => {
  // Event listener logic goes here...

  const lag = performance.now() - event.timeStamp;
  if (lag > 100) {
    ga('send', 'event', {
      eventCategory: 'Performance Metric'
      eventAction: 'input-latency',
      eventLabel: '#subscribe:click',
      eventValue: Math.round(lag),
      nonInteraction: true,
    });
  }
});
```

Como a latência de evento é normalmente resultado de uma tarefa longa, você pode combinar
sua lógica de detecção de latência de evento com sua lógica de detecção de tarefa longa: se uma tarefa
longa estava bloqueando o thread principal ao mesmo tempo que o `event.timeStamp`, você
pode relatar também o valor de atribuição dessa tarefa longa. Isso permitiria que você
desenhasse uma linha muito clara entre a experiência de desempenho negativa e o código
que a causou.

Embora essa técnica não seja perfeita (ela não lida com listeners de eventos longos depois,
na fase de propagação, além de não funcionar com animações
de rolagem ou composição que não são executadas no thread principal), é um bom primeiro passo em direção
ao entendimento da frequência com que códigos JavaScript de execução longa tem afetado a
experiência do usuário.

## Interpretação dos dados

Depois de começar a coletar métricas de desempenho para usuários reais, você precisa
usar essas informações. Os dados de desempenho do usuário real são úteis devido a alguns
motivos principais:

* Validação de que seu aplicativo funciona conforme o esperado.
* Identificação dos locais em que o desempenho fraco está afetando negativamente as conversões
 (independentemente do que isso significa para seu aplicativo).
* Descoberta de oportunidades de melhoria da experiência e satisfação do usuário.

Algo que definitivamente vale a pena comparar é o desempenho do aplicativo em dispositivos móveis
e em computadores. O seguinte gráfico mostra a distribuição do TTI entre computadores
(em azul) e dispositivos móveis (em laranja). Como você pode ver nesse exemplo, o valor de TTI em
dispositivos móveis foi bem maior do que em computadores:

Embora os números apresentados sejam específicos desse aplicativo (e você não deve presumir que seriam os mesmos
em seu caso sem fazer seus próprios testes), esse é um bom exemplo
de abordagem de relatório para suas métricas de uso:

#### Computadores

   Percentil
   TTI (segundos)

   50%
   2,3

   75%
   4,7

   90%
   8,3

#### Dispositivos móveis

   Percentil
   TTI (segundos)

   50%
   3,9

   75%
   8,0

   90%
   12,6

Detalhar seus resultados entre dispositivos móveis e computadores e analisar os dados como
distribuição permite que você tenha informações rápidas a respeito das experiências de usuários reais.
Por exemplo, na tabela acima posso ver facilmente que, para esse aplicativo,
**10% dos usuários de dispositivos móveis levaram mais de 12 segundos para se tornarem interativos!**

### Como o desempenho afeta a empresa

Uma enorme vantagem de rastrear o desempenho em ferramentas de análise é que você pode
usar esses dados para analisar como o desempenho afeta a empresa.

Se você está rastreando conclusões de metas ou conversões de comércio eletrônico em análise,
pode criar relatórios que explorem qualquer correlação entre esses dados e as métricas de
desempenho do aplicativo. Por exemplo:

* Usuários com tempos interativos mais rápidos compram mais?
* Usuários com mais tarefas longas durante a finalização de compra têm taxas mais altas de desistência?

Se correlações forem encontradas, será substancialmente mais fácil fazer a empresa
notar que desempenho é importante e deve ser priorizado.

### Abandono de carregamento

Sabemos que os usuários costumam abandonar a página se ela leva muito tempo para carregar.
Isso significa que todas as nossas métricas de desempenho compartilham do problema
de [viés de sobrevivência](https://en.wikipedia.org/wiki/Survivorship_bias). Ou seja,
os dados não incluem as métricas de carregamento de pessoas que não esperaram a página
terminar de carregar (o que normalmente significa que os números ficam muito baixos).

Embora você não possa rastrear quais seriam os números se esses usuários tivessem
esperado, você pode rastrear a frequência com que isso acontece e também por quanto tempo cada usuário
permaneceu.

Isso é um pouco difícil de fazer com o Google Analytics uma vez que biblioteca analytics.js
é carregado normalmente de forma assíncrona e pode não estar disponível quando o usuário
decide abandonar a página. No entanto, você não precisa aguardar o carregamento de analytics.js
antes de enviar dados para o Google Analytics. Você pode enviá-los diretamente por meio do
[Protocolo de avaliação](/analytics/devguides/collection/protocol/v1/).

Esse código adiciona um listener ao evento
[`visibilitychange`](https://developer.mozilla.org/en-US/docs/Web/Events/visibilitychange)
(que é acionado se a página estiver sendo descarregada ou for para segundo plano)
e ele envia o valor do `performance.now()` nesse ponto.

```
<script>
window.__trackAbandons = () => {
  // Remove the listener so it only runs once.
  document.removeEventListener('visibilitychange', window.__trackAbandons);
  const ANALYTICS_URL = 'https://www.google-analytics.com/collect';
  const GA_COOKIE = document.cookie.replace(
    /(?:(?:^|.*;)\s*_ga\s*\=\s*(?:\w+\.\d\.)([^;]*).*$)|^.*$/, '$1');
  const TRACKING_ID = 'UA-XXXXX-Y';
  const CLIENT_ID =  GA_COOKIE || (Math.random() * Math.pow(2, 52));

  // Send the data to Google Analytics via the Measurement Protocol.
  navigator.sendBeacon && navigator.sendBeacon(ANALYTICS_URL, [
    'v=1', 't=event', 'ec=Load', 'ea=abandon', 'ni=1',
    'dl=' + encodeURIComponent(location.href),
    'dt=' + encodeURIComponent(document.title),
    'tid=' + TRACKING_ID,
    'cid=' + CLIENT_ID,
    'ev=' + Math.round(performance.now()),
  ].join('&'));
};
document.addEventListener('visibilitychange', window.__trackAbandons);
</script>
```

Você pode usar esse código ao copiá-lo no `<head>` do documento e substituir
o marcador `UA-XXXXX-Y` pelo
[código de rastreamento](https://support.google.com/analytics/answer/1008080).

Você também deve remover esse listener quando a página
se tornar interativa ou reportará abandono por carregamento enquanto
também reporta TTI.

```
document.removeEventListener('visibilitychange', window.__trackAbandons);
```

## Otimização de desempenho e prevenção de regressão

O mais extraordinário de definir métricas centradas no usuário é que quando você otimiza dessa forma,
inevitavelmente também melhora a experiência do usuário.

Uma das formas mais simples de melhorar o desempenho é simplesmente enviar menos códigos JavaScript
para o cliente, mas nos casos em que reduzir o tamanho do código não é uma opção, é
essencial que você pense *como* você fornece o JavaScript.

### Otimização de FP/FCP

Você pode diminuir o tempo da primeira exibição e da primeira exibição significativa removendo qualquer script ou folha de estilo
que bloqueie a renderização do `<head>` do documento.

Ao dedicar tempo à identificação do conjunto mínimo de estilos necessários para mostrar ao usuário
que "a página está funcionando" e ao colocá-los inline no `<head>` (ou usando o [push do
servidor HTTP/2](/web/fundamentals/performance/http2/#server_push)), você pode conseguir
tempos de primeira exibição incrivelmente rápidos.

O [padrão shell do aplicativo](/web/updates/2015/11/app-shell) é um ótimo exemplo de
como fazer isso para [Progressive Web Apps](/web/progressive-web-apps/).

### Otimização de FMP/TTI

Depois de identificar os elementos de IU mais importantes de sua página (os elementos
principais), verifique se o carregamento inicial de script contém apenas o
código necessário para renderizar esses elementos e torná-los interativos.

Qualquer código não relacionado aos elementos principais que esteja incluído no pacote
JavaScript inicial aumentará o tempo até a interatividade. Não há motivo
para forçar os dispositivos dos usuários a fazer o download e analisar códigos JavaScript de que eles não
precisam imediatamente.

Como regra geral, você deve tentar minimizar ao máximo o tempo
entre a FMP e o TTI. Nos casos em que não seja possível minimizar esse tempo,
é absolutamente essencial que suas interfaces deixem bem claro que a página ainda não está
interativa.

Uma das experiências mais frustrantes para um usuário é tocar em um elemento e
nada acontecer.

### Prevenção de tarefas longas

Ao dividir seu código e priorizar a ordem em que ele é carregado, você
pode não só tornar suas páginas interativas mais rapidamente, mas também reduzir as tarefas longas.
Assim, poderá ter menos latência de entrada e menos frames lentos.

Além de dividir o código em arquivos separados, você também pode dividir
blocos grandes de código síncrono em blocos menores que podem ser executados
de forma assíncrona ou ser
[adiados para o próximo ponto ocioso](/web/updates/2015/08/using-requestidlecallback).
Ao executar essa lógica de forma assíncrona em blocos menores, você libera espaço no
thread principal para o navegador responder ao comando do usuário.

Por fim, você deve verificar se está testando o código de terceiros e identificando
todos os códigos de execução lenta. Anúncios ou scripts de rastreamento de terceiros que
causam muitas tarefas longas acabam causando mais transtornos do que benefícios
à empresa.

## Prevenção de regressão

Este artigo concentrou-se na medição de desempenho em usuários reais e
, embora seja verdade que os dados RUM são os que realmente importam,
dados de laboratório ainda são cruciais para assegurar que seu aplicativo tenha um bom desempenho (e que não tenha
regressões) antes do lançamento de novos recursos. Testes de laboratório são ideais para detecção de
regressão porque são realizados em um ambiente controlado e são muito menos propensos à
variabilidade aleatória dos testes RUM.

Ferramentas como [Lighthouse](/web/tools/lighthouse/) e [Web Page
Test](https://www.webpagetest.org/) podem ser integradas ao servidor
de integração contínua, e você pode escrever testes que podem causar falha da versão se as métricas principais
regredirem ou ficarem abaixo de determinado limite.

E para códigos já lançados, você pode adicionar [alertas
personalizados](https://support.google.com/analytics/answer/1033021) para informarem se
houver picos inesperados na ocorrência de eventos de desempenho negativo.
Isso pode acontecer, por exemplo, se um terceiro lança uma nova versão de um
de seus serviços e repentinamente seus usuários começam a ver um aumento significativo nas tarefas
longas.

Para impedir regressões com sucesso, você precisa testar o desempenho tanto no
laboratório quanto no ambiente real a cada novo lançamento de recurso.

## Conclusão e próximos passos

Fizemos avanços significativos no ano passado com relação à exposição de métricas centradas no usuário
para desenvolvedores no navegador. No entanto, ainda não acabamos e há muito mais em nossos
planos.

Gostaríamos de padronizar as métricas de tempo para interação e elemento principal para que os
desenvolvedores não tenham que fazer suas próprias medições ou depender de polyfills. Também
gostaríamos de facilitar para os desenvolvedores a atribuição de frames perdidos e latência de
entrada para tarefas longas específicas e o código que as causou.

Embora tenhamos muito trabalho a fazer, estamos empolgados com o avanço que fizemos. Com
novas APIs como `PerformanceObserver` e as tarefas longas com compatibilidade nativa com o
navegador, os desenvolvedores finalmente têm o básico necessário para medir o desempenho
de usuários reais sem comprometer a experiência.

As métricas mais importantes são as que representam experiências de usuários reais
, e nós queremos facilitar ao máximo para os desenvolvedores
a tarefa de encantar seus usuários e criar grandes aplicativos.

## Fique conectado

{% include "web/_shared/helpful.html" %}

Reporte problemas de especificação:

* [https://github.com/w3c/longtasks/issues](https://github.com/w3c/longtasks/issues)
* [https://github.com/WICG/paint-timing/issues](https://github.com/WICG/paint-timing/issues)
* [https://github.com/w3c/performance-timeline/issues](https://github.com/w3c/performance-timeline/issues)

Reporte problemas de polyfill:

* [https://github.com/GoogleChrome/tti-polyfill/issues](https://github.com/GoogleChrome/tti-polyfill/issues)

Faça perguntas:

* [progressive-web-metrics@chromium.org](mailto:progressive-web-metrics@chromium.org)
* [public-web-perf@w3.org](mailto:public-web-perf@w3.org)

Expresse seu apoio sobre novas propostas de API:

* [https://github.com/w3c/charter-webperf/issues](https://github.com/w3c/charter-webperf/issues)


text:
@interface WTDropboxManager : NSObject

@property (nonatomic, copy) void (^beginSessionCompletion)(BOOL linkSuccess);

+ (instancetype)sharedManager;

- (BOOL)isSetup;
- (void)beginSessionForRootAppFolderWithAppKey:(NSString*)appkey withCompletion:(void(^)(BOOL linkSuccess))completion;
- (BOOL)isLogin;
- (BOOL)handleOpenURL:(NSURL *)url;
- (void)linkFromViewController:(UIViewController*)vct;
- (void)unlink;

@property (nonatomic, copy) void (^accountInfoCompleteBlock)(DBUSERSSpaceUsage *space);

- (void)accountInfo;

@property (nonatomic, assign) BOOL recursively;

@property (nonatomic, copy) void (^loadListCompleteBlock)(NSArray *fileList);

- (void)loadListFileFromRootFolder;
- (void)loadListFileFromFolderPath:(NSString*)path;

@property (nonatomic, strong) NSString *downloadFolderPath;
@property (nonatomic, assign) BOOL downloading;
@property (nonatomic, assign) int downloadArrayIndex;
@property (nonatomic, assign) long long finishDownloadByte;
@property (nonatomic, assign) long long totalDownloadByte;
@property (nonatomic, strong) NSMutableArray *downloadArray;
@property (nonatomic, strong) NSMutableArray *downloadedArray;
@property (nonatomic, strong) NSMutableArray *downloadSuccessArray;
@property (nonatomic, strong) NSMutableArray *downloadFailArray;

@property (nonatomic, copy) void (^downloadProgressBlock)(int64_t bytesDownloaded, int64_t totalBytesDownloaded, int64_t totalBytesExpectedToDownload);
@property (nonatomic, copy) void (^downloadCompleteBlock)(BOOL success, NSArray *fileSuccess, NSArray *fileFail);

- (void)downloadFromPath:(DBFILESMetadata*)metadata toFolderPath:(NSString*)localFolderPath;
- (void)downloadFromArray:(NSArray*)array toFolderPath:(NSString*)localFolderPath;
- (void)downloadCancel;

@property (nonatomic, copy) void (^uploadProgressBlock)(int64_t bytesUploaded, int64_t totalBytesUploaded, int64_t totalBytesExpectedToUploaded);
@property (nonatomic, copy) void (^uploadCompleteBlock)(BOOL success, DBFILESUploadError *routeError, DBRequestError *networkError);

- (void)uploadFromPath:(NSString*)localPath toPath:(NSString*)dropboxPath;
- (void)uploadCancel;

@end

#elif WTDropboxManager_VERSION >= 0x00010000

//#import <DropboxSDK/DropboxSDK.h>
//#import <Dropbox/Dropbox.h>

@protocol WTDropboxManagerDelegate <NSObject>

- (void)restClient:(DBRestClient*)client loadedMetadataArray:(NSArray*)metadataArray;

@end

@interface WTDropboxManager : NSObject<DBSessionDelegate,DBRestClientDelegate>

@property (nonatomic, strong) DBSession *dbSession;
@property (nonatomic, copy) void (^beginSessionCompletion)(BOOL linkSuccess,DBSession *session, NSString *userId);

@property (nonatomic, strong) DBRestClient *restClient;
@property (nonatomic, strong) NSMutableDictionary *metadataDictionary;

@property (nonatomic, assign) BOOL recursively;
@property (nonatomic, strong) NSMutableArray *exploreQueue;
@property (nonatomic, strong) NSMutableArray *exploreArrayMetadata;

@property (nonatomic, strong) NSString *downloadFolderPath;
@property (nonatomic, assign) BOOL arrayDownloading;
@property (nonatomic, assign) int downloadArrayIndex;
@property (nonatomic, strong) NSMutableArray *downloadArrayMetadata;
@property (nonatomic, strong) NSMutableArray *downloadSuccessArray;
@property (nonatomic, strong) NSMutableArray *downloadFailArray;

@property (nonatomic, copy) void (^downloadProgressBlock)(BOOL finish, DBMetadata *metadata, float progress);
@property (nonatomic, copy) void (^downloadCompleteBlock)(BOOL success, NSArray *fileSuccess, NSArray *fileFail);

@property (nonatomic, copy) void (^uploadProgressBlock)(BOOL finish, NSString *file, float progress, NSError *error);

@property (nonatomic, copy) void (^loadRevisionBlock)(BOOL finish, NSString *file, NSArray *revisions, NSError *error);

//@property (nonatomic, assign) BOOL login;
@property (nonatomic, assign) id<DBSessionDelegate,DBRestClientDelegate,WTDropboxManagerDelegate> managerDelegate;

+ (instancetype)sharedManager;

- (void)addRevForFile:(DBMetadata*)metadata;
- (DBMetadata*)metadataForPath:(NSString*)path;
- (NSString*)revForFilePath:(NSString*)filePath;
- (NSString*)hashForFolderPath:(NSString*)folderPath;

//core api
// call this function in appdelegate
- (void)beginSessionForRootAppFolderWithAppKey:(NSString*)key appSecrect:(NSString*)secret withCompletion:(void (^)(BOOL linkSuccess,DBSession *session, NSString *userId))completion;
- (void)beginSessionForRootDropboxWithAppKey:(NSString*)key appSecrect:(NSString*)secret withCompletion:(void (^)(BOOL linkSuccess,DBSession *session, NSString *userId))completion;

- (void)linkFromViewController:(UIViewController*)vct;
- (void)unlink;
- (BOOL)isLogin;

- (BOOL)handleOpenURL:(NSURL *)url;
- (void)openDropBoxOnAppStore;
- (NSDateFormatter*)dropboxDateFormat;

//funcion api

- (void)uploadFileFromPath:(NSString*)fromPath;
- (void)uploadFileFromPath:(NSString*)fromPath toPath:(NSString*)toPath;
- (void)uploadNewFileFromPath:(NSString*)fromPath toPath:(NSString*)toPath;
- (void)uploadCancel:(NSString*)path;
- (void)uploadCancel;

- (void)listFileFromRootFolder;
- (void)listFileFromFolderPath:(NSString*)path;
- (void)listFileFromFolderPath:(NSString*)path recursive:(BOOL)recursive;

- (void)loadListFileFromRootFolder;
- (void)loadListFileFromFolderPath:(NSString*)path;
- (void)loadListFileFromFolderPath:(NSString*)path recursive:(BOOL)recursive;

//- (void)download;
- (void)downloadFileFromPath:(NSString*)dropboxPath toPath:(NSString*)localPath;
- (void)downloadFileFromPath:(NSString*)dropboxPath toFolderPath:(NSString*)localFolderPath;

- (void)downloadFileFromMetadatas:(NSArray*)dropboxMetadatas toFolderPath:(NSString*)localFolderPath;
- (void)downloadFileFromPaths:(NSArray*)dropboxPaths toFolderPath:(NSString*)localFolderPath;

- (void)downloadCancel;

- (void)loadRevisionsForFile:(NSString *)path;

@end

#endif

//@interface WTDropboxSyncManager : NSObject
//
//@end

redpajama_set_name: RedPajamaGithub


text:
using System;
using System.Collections.Generic;
using System.Data.Entity;
using System.Linq;
using System.Web;
using GameTimeApp.Core.Models;

namespace GameTimeApp.Persistence
{
    public interface IApplicationDbContext
    {
        DbSet<Quest> Quests { get; set; }
        DbSet<EventLog> EventLogs { get; set; }
        void Dispose();
    }
}


text:
<?php

namespace Purr\Exception;

/**
 * Exception when importing of a modules fails.
 */
class ModuleImportException extends RuntimeException implements ExceptionInterface
{

}


text:
package tr.xip.wanikani.models;

import java.io.Serializable;

/**
 * Created by xihsa_000 on 3/12/14.
 */
public class Error implements Serializable {
    private String code;
    private String message;

    public String getErrorCode() {
        return code;
    }

    public String getErrorMessage() {
        return message;
    }
}


text:
package com.skype;

import java.io.File;

import com.skype.connector.Connector;
import com.skype.connector.ConnectorException;

/**
 * Main view (not model) class of the Skype Java API.
 * Use this class staticly to do view actions (show option dialogs or switch tabs, etc).
 * @see Skype
 * @author Koji Hisano
 */
public final class SkypeClient {

	/**
	 *
	 * This class should be used staticly, so making the constructor private prefents instantiation.
	 */
	private SkypeClient() {
	}

	/**
     * Enumeration of the OPTIONS page.
     * Options dialog of Skype client.
     */
    public enum OptionsPage {
        /**
         * GENERAL - general options dialog.
         * PRIVACY - privacy options dialog.
         * NOTIFICATIONS - notifications options dialog.
         * SOUNDALERTS - soundalerts options dialog.
         * SOUNDDEVICES - sound devices options dialog.
         * HOTKEYS - hotkeys options dialog.
         * CONNECTION - connection options dialog.
         * VOICEMAIL - voicemail options dialog.
         * CALLFORWARD - callforward options dialog.
         * VIDEO - video options dialog.
         * ADVANCED - advanced options dialog.
         *
         */
        GENERAL, PRIVACY, NOTIFICATIONS, SOUNDALERTS, SOUNDDEVICES, HOTKEYS, CONNECTION, VOICEMAIL, CALLFORWARD, VIDEO, ADVANCED;
    }

    /**
     * Enumeration of keypad keys.
     */
    public enum Button {
        /**
         * KEY_0 - 0 on the callpad.
         * KEY_1 - 1 on the callpad.
         * KEY_2 - 2 on the callpad.
         * KEY_3 - 3 on the callpad.
         * KEY_4 - 4 on the callpad.
         * KEY_5 - 5 on the callpad.
         * KEY_6 - 6 on the callpad.
         * KEY_7 - 7 on the callpad.
         * KEY_8 - 8 on the callpad.
         * KEY_9 - 9 on the callpad.
         * KEY_A - A on the callpad.
         * KEY_B - B on the callpad.
         * KEY_C - C on the callpad.
         * KEY_D - D on the callpad.
         * KEY_E - E on the callpad.
         * KEY_F - F on the callpad.
         * KEY_G - G on the callpad.
         * KEY_H - H on the callpad.
         * KEY_I - I on the callpad.
         * KEY_J - J on the callpad.
         * KEY_K - K on the callpad.
         * KEY_L - L on the callpad.
         * KEY_M - M on the callpad.
         * KEY_N - N on the callpad.
         * KEY_O - O on the callpad.
         * KEY_P - P on the callpad.
         * KEY_Q - Q on the callpad.
         * KEY_R - R on the callpad.
         * KEY_S - S on the callpad.
         * KEY_T - T on the callpad.
         * KEY_U - U on the callpad.
         * KEY_V - V on the callpad.
         * KEY_W - W on the callpad.
         * KEY_X - X on the callpad.
         * KEY_Y - Y on the callpad.
         * KEY_Z - Z on the callpad.
         * KEY_SHARP - # on the callpad.
         * KEY_ASTERIX - * on the callpad.
         * KEY_PLUS - + on the callpad.
         * KEY_UP - on the callpad.
         * KEY_DOWN - on the callpad.
         * KEY_YES - yes on the callpad.
         * KEY_NO - no on the callpad.
         * KEY_PAGEUP - on the callpad.
         * KEY_PAGEDOW - on the callpad.
         * KEY_SKYPE - on the callpad.
         */
        KEY_0, KEY_1, KEY_2, KEY_3, KEY_4, KEY_5, KEY_6, KEY_7, KEY_8, KEY_9, KEY_A, KEY_B, KEY_C, KEY_D, KEY_E, KEY_F, KEY_G, KEY_H, KEY_I, KEY_J, KEY_K, KEY_L, KEY_M, KEY_N, KEY_O, KEY_P, KEY_Q, KEY_R, KEY_S, KEY_T, KEY_U, KEY_V, KEY_W, KEY_X, KEY_Y, KEY_Z, KEY_SHARP("#"), KEY_ASTERISK("*"), KEY_PLUS("+"), KEY_UP, KEY_DOWN, KEY_YES, KEY_NO, KEY_PAGEUP, KEY_PAGEDOWN, KEY_SKYPE;

        /** Key instance. */
        private String key;

        /** Constructor. */
        private Button() {
        }

        /**
         * Constructor using a String as button reference.
         * @param newKey The button.
         */
        private Button(String newKey) {
            this.key = newKey;
        }

        /**
         * Get the key.
         * @return The string.
         * */
        private String getKey() {
            if (key != null) {
                return key;
            } else {
                return name().substring(name().indexOf('_') + 1);
            }
        }
    }

    public enum WindowState {
        NORMAL, MINIMIZED, MAXIMIZED, HIDDEN;
    }

    /**
     * Put focus on the Skype client window, not any Java window.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showSkypeWindow() throws SkypeException {
        Utils.executeWithErrorCheck("FOCUS");
    }

    /**
     * Remove focus on Skype client window, not any Java window.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void hideSkypeWindow() throws SkypeException {
        Utils.executeWithErrorCheck("MINIMIZE");
    }

    /**
     * Open the "Add friend" window of Skype client.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showAddFriendWindow() throws SkypeException {
        Utils.executeWithErrorCheck("OPEN ADDAFRIEND");
    }

    /**
     * Open the "Add friend" window if skypeId exist.
     * @param skypeId the Skype ID to check before opening the window.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showAddFriendWindow(String skypeId) throws SkypeException {
        Utils.checkNotNull("skypeId", skypeId);
        Utils.executeWithErrorCheck("OPEN ADDAFRIEND " + skypeId);
    }

    /**
     * Open a chatwindow to another Skype user.
     * @param skypeId The user to open a chat with.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showChatWindow(String skypeId) throws SkypeException {
        Utils.checkNotNull("skypeId", skypeId);
        Utils.executeWithErrorCheck("OPEN IM " + skypeId);
    }

    /**
     * Open a chatwindow to another skype user and send a message.
     * @param skypeId The other user to chat with.
     * @param message The message to send.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showChatWindow(String skypeId, String message) throws SkypeException {
        Utils.checkNotNull("skypeId", skypeId);
        Utils.checkNotNull("message", message);
        Utils.executeWithErrorCheck("OPEN IM " + skypeId + " " + message);
    }

    /**
     * Open File transfer window ten send a file to another Skype user.
     * @param skypeId The user to send the file to.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showFileTransferWindow(String skypeId) throws SkypeException {
        Utils.checkNotNull("skypeId", skypeId);
        Utils.executeWithErrorCheck("OPEN FILETRANSFER " + skypeId);
    }

    /**
     * Show file transfer windows with a specific folder to send a file to another Skype user.
     * @param skypeId the user to send the file to.
     * @param folder the folder to show in the window.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showFileTransferWindow(String skypeId, File folder) throws SkypeException {
        Utils.checkNotNull("skypeId", skypeId);
        Utils.checkNotNull("folder", folder);
        Utils.executeWithErrorCheck("OPEN FILETRANSFER " + skypeId + " IN " + folder,"OK");
    }

    /**
     * Show the file transfer window to send a file to several other Skype users.
     * @param skypeIds multiple Skype users to send file to.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showFileTransferWindow(String[] skypeIds) throws SkypeException {
        Utils.checkNotNull("skypeIds", skypeIds);
        Utils.executeWithErrorCheck("OPEN FILETRANSFER " + Utils.convertToCommaSeparatedString(skypeIds));
    }

    /**
     * Show file transfer window with a specific Folder to send a file to multiple Skype users.
     * @param skypeIds multiple Skype users to send file to.
     * @param folder the folder to open with the dialog.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showFileTransferWindow(String[] skypeIds, File folder) throws SkypeException {
        Utils.checkNotNull("skypeIds", skypeIds);
        Utils.checkNotNull("folder", folder);
        Utils.executeWithErrorCheck("OPEN FILETRANSFER " + Utils.convertToCommaSeparatedString(skypeIds) + " IN " + folder);
    }

    /**
     * Open the Skype client profile window.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showProfileWindow() throws SkypeException {
        Utils.executeWithErrorCheck("OPEN PROFILE");
    }

    /**
     * Open the User Information window with the info on a Skype user.
     * @param skypeId The skype user to show.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showUserInformationWindow(String skypeId) throws SkypeException {
        Utils.checkNotNull("skypeId", skypeId);
        Utils.executeWithErrorCheck("OPEN USERINFO " + skypeId);
    }

    /**
     * Open the conference window of the Skype client.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showConferenceWindow() throws SkypeException {
        Utils.executeWithErrorCheck("OPEN CONFERENCE");
    }

    /**
     * Open the search window of the Skype Client.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showSearchWindow() throws SkypeException {
        Utils.executeWithErrorCheck("OPEN SEARCH");
    }

    /**
     * Open the Options window of the Skype Client.
     * @see OptionsPage
     * @param page the page to ope in front.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showOptionsWindow(OptionsPage page) throws SkypeException {
        Utils.executeWithErrorCheck("OPEN OPTIONS " + page.toString().toLowerCase());
    }

    /**
     * Focus the Call history tab of the Skype client.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showCallHistoryTab() throws SkypeException {
        Utils.executeWithErrorCheck("OPEN CALLHISTORY");
    }

    /**
     * Focus the Contacts tab of the Skype client window.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showContactsTab() throws SkypeException {
        Utils.executeWithErrorCheck("OPEN CONTACTS");
    }

    /**
     * Focus dialpad tab on the Skype client window.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showDialPadTab() throws SkypeException {
        Utils.executeWithErrorCheck("OPEN DIALPAD");
    }

    /**
     * Open send contacts window.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showSendContactsWindow() throws SkypeException {
        Utils.executeWithErrorCheck("OPEN SENDCONTACTS");
    }

    /**
     * Show blacked users window of the Skype client.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showBlockedUsersWindow() throws SkypeException {
        Utils.executeWithErrorCheck("OPEN BLOCKEDUSERS");
    }

    /**
     * Show import contacts window of Skype client.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showImportContactsWindow() throws SkypeException {
        Utils.executeWithErrorCheck("OPEN IMPORTCONTACTS");
    }

    /**
     * Show the getting started window of the Skype client.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showGettingStartedWindow() throws SkypeException {
        Utils.executeWithErrorCheck("OPEN GETTINGSTARTED");
    }

    /**
     * Show the request authorisation window for a Skype user ID.
     * @param skypeId the User to ask authorisation for.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void showRequestAuthorizationWindow(String skypeId) throws SkypeException {
        Utils.executeWithErrorCheck("OPEN AUTHORIZATION " + skypeId);
    }

    /**
     * Press a button in the Skype client window.
     * @see Button
     * @param button The button to press.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void pressButton(Button button) throws SkypeException {
        Utils.executeWithErrorCheck("BTN_PRESSED " + button.getKey());
    }

    /**
     * Release a pressed button in the Skype client window.
     * @see Button
     * @param button the button to release.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void releaseButton(Button button) throws SkypeException {
        Utils.executeWithErrorCheck("BTN_RELEASED " + button.getKey());
    }

    /**
     * Open the Test video dialog of the Skype client.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void openVideoTestWindow() throws SkypeException {
        Utils.executeWithErrorCheck("OPEN VIDEOTEST");
    }

    /**
     * Open the Video options window of the Skype client.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     */
    public static void openVideoOptionsWindow() throws SkypeException {
        Utils.executeWithErrorCheck("OPEN OPTIONS VIDEO");
    }

    public static String getUILanguageByISOCode() throws SkypeException {
        return Utils.getProperty("UI_LANGUAGE");
    }

    public static void setUILanguageByISOCode(final String newValue) throws SkypeException {
        Utils.setProperty("UI_LANGUAGE", newValue);
    }

    public static File getWallPaper() throws SkypeException {
        return new File(Utils.getProperty("WALLPAPER"));
    }

    public static void setWallPaper(final File newValue) throws SkypeException {
        if (newValue != null) {
            Utils.setProperty("WALLPAPER", newValue.getAbsolutePath());
        } else {
            Utils.setProperty("WALLPAPER", "");
        }
    }

    /**
     * Sets the Skype silent mode.
     * @param on if true turn on the silent mode.
     * @return true if the user responds ok.
     * @throws SkypeException when connection has gone bad or ERROR reply.
     * @since 2.6.0.84
     */
    public static boolean setSilentMode(boolean on) throws SkypeException {
        try {
            String command = "SET SILENT_MODE " + (on? "ON": "OFF");
            String responseHeader = "SILENT_MODE ";
            String response = Connector.getInstance().execute(command, responseHeader);
            Utils.checkError(response);
            String responseValue = response.substring(responseHeader.length());
            return "ON".equals(responseValue);
        } catch (ConnectorException e) {
            Utils.convertToSkypeException(e);
            return false;
        }
    }

    public static EventMessage addEventMessage(String caption) throws SkypeException {
        return addEventMessage(caption, caption);
    }

    public static EventMessage addEventMessage(String caption, String hint) throws SkypeException {
        Utils.checkNotNull("caption", caption);
        Utils.checkNotNull("hint", hint);
        try {
            EventMessage eventMessage = EventMessage.addEventMessage(caption, hint);
            String command = "CREATE EVENT " + eventMessage.getId() + " CAPTION \"" + caption + "\" HINT \"" + hint + "\"";
            String responseHeader = "EVENT " + eventMessage.getId() + " CREATED";
            String response = Connector.getInstance().execute(command, responseHeader);
            Utils.checkError(response);
            return eventMessage;
        } catch (ConnectorException e) {
            Utils.convertToSkypeException(e);
            return null;
        }
    }

    public static void removeEventMessage(EventMessage eventMessage) throws SkypeException {
        eventMessage.dispose();
    }

    public static MenuItem addMenuItem(MenuItem.Context context, String caption, String hint, File iconFile, boolean enabled, String targetSkypeId, boolean multipleContactsEnabled) throws SkypeException {
        try {
            MenuItem menuItem = MenuItem.addMenuItem(context, caption, hint, iconFile, enabled, targetSkypeId, multipleContactsEnabled);
            String command = "CREATE MENU_ITEM " + menuItem.getId() + " CONTEXT " + context.name().toLowerCase() + " CAPTION \"" + caption + "\"";
            if (hint != null) {
                command += " HINT \"" + hint + "\"";
            }
            if (iconFile != null) {
                command += " ICON \"" + iconFile.getAbsolutePath() + "\"";
            }
            if (!enabled) {
                command += " ENABLED false";
            }
            if (targetSkypeId != null) {
                command += " CONTACT_TYPE_FILTER \"" + targetSkypeId + "\"";
            }
            if (!multipleContactsEnabled) {
                command += " ENABLE_MULTIPLE_CONTACTS false";
            }
            String responseHeader = "MENU_ITEM " + menuItem.getId() + " CREATED";
            String response = Connector.getInstance().execute(command, responseHeader);
            Utils.checkError(response);
            return menuItem;
        } catch (ConnectorException e) {
            Utils.convertToSkypeException(e);
            return null;
        }
    }

    public static void removeMenuItem(MenuItem menuItem) throws SkypeException {
        menuItem.dispose();
    }

    public static void setMainWindowState(WindowState newValue) throws SkypeException {
        Utils.setProperty("WINDOWSTATE", newValue.name());
    }

    public static WindowState getMainWindowState() throws SkypeException {
        return WindowState.valueOf(Utils.getProperty("WINDOWSTATE"));
    }
}


text:
@implementation CityModel

+ (instancetype)cityTitles:(NSArray<CityModel *> *)datas {
    CityModel *city = [CityModel new];
    city.datas = datas;

    NSMutableArray *titles = @[].mutableCopy;
    [datas enumerateObjectsUsingBlock:^(CityModel * _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
        [titles addObject:obj.title];
    }];
    city.titles = titles.copy;

    return city;

}
+ (instancetype)cityWithDictionary:(NSDictionary *)dictionary {
    return [[self alloc] initWithDictionary:dictionary];
}

- (instancetype)initWithDictionary:(NSDictionary *)dictionary {

    if (self = [super init]) {
        _title = dictionary[@"first_letter"];
        _name  = dictionary[@"name"];
        NSArray *datas = dictionary[@"list_datas"];
        if (!datas.count) return self;
        _datas = [self.class cityWithDictionarys:datas];
    }
    return self;
}

+ (NSArray<CityModel *> *)cityWithDictionarys:(NSArray<NSDictionary *> *)dictionarys {

    NSMutableArray *models = @[].mutableCopy;
    [dictionarys enumerateObjectsUsingBlock:^(NSDictionary * _Nonnull obj, NSUInteger idx, BOOL * _Nonnull stop) {
        CityModel *city = [self.class cityWithDictionary:obj];

        if (dictionarys.count == 1 || idx == dictionarys.count - 1) {
            city.mark = NO;
        } else {
            city.mark = YES;
        }
        [models addObject:city];
    }];
    return models.copy;
}

@end


text:
require_relative 'application'

# Load fluentd libraries & plugins
require "fluent/load"

# Initialize the Rails application.
Rails.application.initialize!


text:
SYNONYM

#### According to
Index Fungorum

#### Published in
null

#### Original name
Agaricus lacrymabundus Bull., 1785

### Remarks
null


text:
package com.facebook.react.uiapp;

import android.app.Application;

import com.facebook.react.ReactApplication;
import com.facebook.react.ReactNativeHost;
import com.facebook.react.ReactPackage;
import com.facebook.react.shell.MainReactPackage;

import java.util.Arrays;
import java.util.List;

import javax.annotation.Nullable;

public class RNTesterApplication extends Application implements ReactApplication {
  private final ReactNativeHost mReactNativeHost = new ReactNativeHost(this) {
    @Override
    public String getJSMainModuleName() {
      return "RNTester/js/RNTesterApp.android";
    }

    @Override
    public @Nullable String getBundleAssetName() {
      return "RNTesterApp.android.bundle";
    }

    @Override
    public boolean getUseDeveloperSupport() {
      return true;
    }

    @Override
    public List<ReactPackage> getPackages() {
      return Arrays.<ReactPackage>asList(
        new MainReactPackage()
      );
    }
  };

  @Override
  public ReactNativeHost getReactNativeHost() {
    return mReactNativeHost;
  }
};


text:
Obras

<?php
if(!($_SESSION['usuario']['tipo'] == 1 || $_SESSION['usuario']['tipo'] == 2))
{
  echo '';
}
if(!($_SESSION['usuario']['tipo'] == 1 || $_SESSION['usuario']['tipo'] == 2))
{
  echo '';
}
  require_once("clases/Libro.php");
  require_once("clases/CopiaLibro.php");
  if ($_POST) {
    $libro = $_POST['libro'];
    $total = intval($_POST['total']);
    $errors = array();
    if(!(isset($libro) && is_numeric($libro)))
      $errors['libro'][] = "Error en codigo de obra";
    if(!(isset($total) && is_numeric($total) && is_integer($total)))
      $errors['total'][] = "Cantidad ser numérica y entera";
    if(!(isset($total) && $total > 0))
      $errors['total'][] = "Cantidad debe ser mayor a 0";
    if(isset($errors) && count($errors)==0){
      CopiaLibros::crea($libro,$total);
      $libro = new Libro($libro);
      echo '
Fueron agregados '.$total.' al libro '.$libro->getTitulo().'
';
    }
  }
?>

Agregar copias de obras

    <form class="form-horizontal" method="post">

          Obras

            <select name="libro" id="libro" class="form-control chosen">
              <?php
              $query = Libros::LibrosActivos();
              while ($fila = mysql_fetch_array($query)) {
                echo '<option value="'.$fila['CodLibro'].'">('.$fila['CodLibro'].') '.$fila['Titulo'].'</option>';
              }
              ?>
            </select>

        <?php if (isset($errors) && isset($errors['libro'])): ?>
          <?php foreach ($errors['libro'] as $data): ?>

<?=$data?>

          <?php endforeach ?>
        <?php endif ?>

          Cantidad

            <input type="text" class="form-control" id="total" name="total" placeholder="Cantidad de copias">

        <?php if (isset($errors) && isset($errors['total'])): ?>
          <?php foreach ($errors['total'] as $data): ?>

<?=$data?>

          <?php endforeach ?>
        <?php endif ?>

          <button type="reset" class="btn btn-default" >Cancelar</button>
          <button type="submit" class="btn btn-primary">Registrar</button>

    </form>


text:
int main(int, char**)
{
    // Setup Allegro
    al_init();
    al_install_keyboard();
    al_install_mouse();
    al_init_primitives_addon();
    al_set_new_display_flags(ALLEGRO_RESIZABLE);
    ALLEGRO_DISPLAY* display = al_create_display(1280, 720);
    al_set_window_title(display, "ImGui Allegro 5 example");
    ALLEGRO_EVENT_QUEUE* queue = al_create_event_queue();
    al_register_event_source(queue, al_get_display_event_source(display));
    al_register_event_source(queue, al_get_keyboard_event_source());
    al_register_event_source(queue, al_get_mouse_event_source());

    // Setup Dear ImGui binding
    IMGUI_CHECKVERSION();
    ImGui::CreateContext();
    ImGuiIO& io = ImGui::GetIO(); (void)io;
    //io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;  // Enable Keyboard Controls
    ImGui_ImplAllegro5_Init(display);

    // Setup style
    ImGui::StyleColorsDark();
    //ImGui::StyleColorsClassic();

    // Load Fonts
    // - If no fonts are loaded, dear imgui will use the default font. You can also load multiple fonts and use ImGui::PushFont()/PopFont() to select them.
    // - AddFontFromFileTTF() will return the ImFont* so you can store it if you need to select the font among multiple.
    // - If the file cannot be loaded, the function will return NULL. Please handle those errors in your application (e.g. use an assertion, or display an error and quit).
    // - The fonts will be rasterized at a given size (w/ oversampling) and stored into a texture when calling ImFontAtlas::Build()/GetTexDataAsXXXX(), which ImGui_ImplXXXX_NewFrame below will call.
    // - Read 'misc/fonts/README.txt' for more instructions and details.
    // - Remember that in C/C++ if you want to include a backslash \ in a string literal you need to write a double backslash \\ !
    //io.Fonts->AddFontDefault();
    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/Roboto-Medium.ttf", 16.0f);
    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/Cousine-Regular.ttf", 15.0f);
    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/DroidSans.ttf", 16.0f);
    //io.Fonts->AddFontFromFileTTF("../../misc/fonts/ProggyTiny.ttf", 10.0f);
    //ImFont* font = io.Fonts->AddFontFromFileTTF("c:\\Windows\\Fonts\\ArialUni.ttf", 18.0f, NULL, io.Fonts->GetGlyphRangesJapanese());
    //IM_ASSERT(font != NULL);

    bool show_demo_window = true;
    bool show_another_window = false;
    ImVec4 clear_color = ImVec4(0.45f, 0.55f, 0.60f, 1.00f);

    // Main loop
    bool running = true;
    while (running)
    {
        // Poll and handle events (inputs, window resize, etc.)
        // You can read the io.WantCaptureMouse, io.WantCaptureKeyboard flags to tell if dear imgui wants to use your inputs.
        // - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application.
        // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application.
        // Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
        ALLEGRO_EVENT ev;
        while (al_get_next_event(queue, &ev))
        {
            ImGui_ImplAllegro5_ProcessEvent(&ev);
            if (ev.type == ALLEGRO_EVENT_DISPLAY_CLOSE)
                running = false;
            if (ev.type == ALLEGRO_EVENT_DISPLAY_RESIZE)
            {
                ImGui_ImplAllegro5_InvalidateDeviceObjects();
                al_acknowledge_resize(display);
                ImGui_ImplAllegro5_CreateDeviceObjects();
            }
        }

        // Start the Dear ImGui frame
        ImGui_ImplAllegro5_NewFrame();
        ImGui::NewFrame();

        // 1. Show the big demo window (Most of the sample code is in ImGui::ShowDemoWindow()! You can browse its code to learn more about Dear ImGui!).
        if (show_demo_window)
            ImGui::ShowDemoWindow(&show_demo_window);

        // 2. Show a simple window that we create ourselves. We use a Begin/End pair to created a named window.
        {
            static float f = 0.0f;
            static int counter = 0;

            ImGui::Begin("Hello, world!");                          // Create a window called "Hello, world!" and append into it.

            ImGui::Text("This is some useful text.");               // Display some text (you can use a format strings too)
            ImGui::Checkbox("Demo Window", &show_demo_window);      // Edit bools storing our window open/close state
            ImGui::Checkbox("Another Window", &show_another_window);

            ImGui::SliderFloat("float", &f, 0.0f, 1.0f);            // Edit 1 float using a slider from 0.0f to 1.0f
            ImGui::ColorEdit3("clear color", (float*)&clear_color); // Edit 3 floats representing a color

            if (ImGui::Button("Button"))                            // Buttons return true when clicked (most widgets return true when edited/activated)
                counter++;
            ImGui::SameLine();
            ImGui::Text("counter = %d", counter);

            ImGui::Text("Application average %.3f ms/frame (%.1f FPS)", 1000.0f / ImGui::GetIO().Framerate, ImGui::GetIO().Framerate);
            ImGui::End();
        }

        // 3. Show another simple window.
        if (show_another_window)
        {
            ImGui::Begin("Another Window", &show_another_window);   // Pass a pointer to our bool variable (the window will have a closing button that will clear the bool when clicked)
            ImGui::Text("Hello from another window!");
            if (ImGui::Button("Close Me"))
                show_another_window = false;
            ImGui::End();
        }

        // Rendering
        ImGui::Render();
        al_clear_to_color(al_map_rgba_f(clear_color.x, clear_color.y, clear_color.z, clear_color.w));
        ImGui_ImplAllegro5_RenderDrawData(ImGui::GetDrawData());
        al_flip_display();
    }

    // Cleanup
    ImGui_ImplAllegro5_Shutdown();
    ImGui::DestroyContext();
    al_destroy_event_queue(queue);
    al_destroy_display(display);

    return 0;
}


text:
package com.iphone567.user.service;

import com.iphone567.user.domain.User;

public interface UserService {
	public int register(User user) throws Exception;
	public int login(User user) throws Exception;
	public int updateInfo(User user) throws Exception;
}


text:
ACCEPTED

#### According to
Index Fungorum

#### Published in
null

#### Original name
Heterochaete cheesmanii Wakef.

### Remarks
null


text:
package org.tguduru.guava.domain;

/**
 * A simple pojo holds data about a mobile phone
 * @author Guduru, Thirupathi Reddy
 * @modified 11/12/15
 */
public class MobilePhone {
    private final String model;
    private final Color color;
    private final OS os;

    public MobilePhone(final String model, final Color color, final OS os) {
        this.model = model;
        this.color = color;
        this.os = os;
    }

    public String getModel() {
        return model;
    }

    public Color getColor() {
        return color;
    }

    public OS getOs() {
        return os;
    }

    @Override
    public String toString() {
        final StringBuilder sb = new StringBuilder(200);
        sb.append("MobilePhone [");
        sb.append("model='").append(model).append('\'');
        sb.append(", color=").append(color);
        sb.append(", os=").append(os);
        sb.append("]");
        return sb.toString();
    }
}


text:
package mesosphere.marathon.api.v2.json

import mesosphere.marathon.MarathonSpec
import mesosphere.marathon.api.JsonTestHelper
import mesosphere.marathon.api.v2.ValidationHelper
import mesosphere.marathon.health.HealthCheck
import mesosphere.marathon.state.Container._
import mesosphere.marathon.state.DiscoveryInfo.Port
import mesosphere.marathon.state.PathId._
import mesosphere.marathon.state._
import org.apache.mesos.{ Protos => mesos }
import play.api.data.validation.ValidationError
import play.api.libs.json.{ JsPath, JsError, Json }

import scala.collection.immutable.Seq
import scala.concurrent.duration._

import com.wix.accord._

import scala.util.Try

class AppUpdateTest extends MarathonSpec {
  import Formats._
  import mesosphere.marathon.integration.setup.V2TestFormats._

  test("Validation") {
    def shouldViolate(update: AppUpdate, path: String, template: String): Unit = {
      val violations = validate(update)
      assert(violations.isFailure)
      assert(ValidationHelper.getAllRuleConstrains(violations).exists(v =>
        v.path.getOrElse(false) == path && v.message == template
      ))
    }

    def shouldNotViolate(update: AppUpdate, path: String, template: String): Unit = {
      val violations = validate(update)
      assert(!ValidationHelper.getAllRuleConstrains(violations).exists(v =>
        v.path.getOrElse(false) == path && v.message == template))
    }

    val update = AppUpdate()

    shouldViolate(
      update.copy(portDefinitions = Some(PortDefinitions(9000, 8080, 9000))),
      "/portDefinitions",
      "Ports must be unique."
    )

    shouldViolate(
      update.copy(portDefinitions = Some(Seq(
        PortDefinition(port = 9000, name = Some("foo")),
        PortDefinition(port = 9001, name = Some("foo"))))
      ),
      "/portDefinitions",
      "Port names must be unique."
    )

    shouldNotViolate(
      update.copy(portDefinitions = Some(Seq(
        PortDefinition(port = 9000, name = Some("foo")),
        PortDefinition(port = 9001, name = Some("bar"))))
      ),
      "/portDefinitions",
      "Port names must be unique."
    )

    shouldViolate(update.copy(mem = Some(-3.0)), "/mem", "got -3.0, expected 0.0 or more")
    shouldViolate(update.copy(cpus = Some(-3.0)), "/cpus", "got -3.0, expected 0.0 or more")
    shouldViolate(update.copy(disk = Some(-3.0)), "/disk", "got -3.0, expected 0.0 or more")
    shouldViolate(update.copy(instances = Some(-3)), "/instances", "got -3, expected 0 or more")
  }

  private[this] def fromJsonString(json: String): AppUpdate = {
    Json.fromJson[AppUpdate](Json.parse(json)).get
  }

  test("SerializationRoundtrip for empty definition") {
    val update0 = AppUpdate(container = Some(Container.Empty))
    JsonTestHelper.assertSerializationRoundtripWorks(update0)
  }

  ignore("SerializationRoundtrip for extended definition") {
    val update1 = AppUpdate(
      cmd = Some("sleep 60"),
      args = None,
      user = Some("nobody"),
      env = Some(Map("LANG" -> "en-US")),
      instances = Some(16),
      cpus = Some(2.0),
      mem = Some(256.0),
      disk = Some(1024.0),
      executor = Some("/opt/executors/bin/some.executor"),
      constraints = Some(Set()),
      fetch = Some(Seq(FetchUri(uri = "http://dl.corp.org/prodX-1.2.3.tgz"))),
      backoff = Some(2.seconds),
      backoffFactor = Some(1.2),
      maxLaunchDelay = Some(1.minutes),
      container = Some(
        Container(
          `type` = mesos.ContainerInfo.Type.DOCKER,
          volumes = Nil,
          docker = Some(Docker(image = "docker:///group/image"))
        )
      ),
      healthChecks = Some(Set[HealthCheck]()),
      dependencies = Some(Set[PathId]()),
      upgradeStrategy = Some(UpgradeStrategy.empty),
      labels = Some(
        Map(
          "one" -> "aaa",
          "two" -> "bbb",
          "three" -> "ccc"
        )
      ),
      ipAddress = Some(IpAddress(
        groups = Seq("a", "b", "c"),
        labels = Map(
          "foo" -> "bar",
          "baz" -> "buzz"
        ),
        discoveryInfo = DiscoveryInfo(
          ports = Seq(Port(name = "http", number = 80, protocol = "tcp"))
        )
      ))
    )
    JsonTestHelper.assertSerializationRoundtripWorks(update1)
  }

  test("Serialization result of empty container") {
    val update2 = AppUpdate(container = None)
    val json2 =
      """
      {
        "cmd": null,
        "user": null,
        "env": null,
        "instances": null,
        "cpus": null,
        "mem": null,
        "disk": null,
        "executor": null,
        "constraints": null,
        "uris": null,
        "ports": null,
        "backoffSeconds": null,
        "backoffFactor": null,
        "container": null,
        "healthChecks": null,
        "dependencies": null,
        "version": null
      }
    """
    val readResult2 = fromJsonString(json2)
    assert(readResult2 == update2)
  }

  test("Serialization result of empty ipAddress") {
    val update2 = AppUpdate(ipAddress = None)
    val json2 =
      """
      {
        "cmd": null,
        "user": null,
        "env": null,
        "instances": null,
        "cpus": null,
        "mem": null,
        "disk": null,
        "executor": null,
        "constraints": null,
        "uris": null,
        "ports": null,
        "backoffSeconds": null,
        "backoffFactor": null,
        "container": null,
        "healthChecks": null,
        "dependencies": null,
        "ipAddress": null,
        "version": null
      }
      """
    val readResult2 = fromJsonString(json2)
    assert(readResult2 == update2)
  }

  test("Empty json corresponds to default instance") {
    val update3 = AppUpdate()
    val json3 = "{}"
    val readResult3 = fromJsonString(json3)
    assert(readResult3 == update3)
  }

  test("Args are correctly read") {
    val update4 = AppUpdate(args = Some(Seq("a", "b", "c")))
    val json4 = """{ "args": ["a", "b", "c"] }"""
    val readResult4 = fromJsonString(json4)
    assert(readResult4 == update4)
  }

  test("'version' field can only be combined with 'id'") {
    assert(AppUpdate(version = Some(Timestamp.now())).onlyVersionOrIdSet)

    assert(AppUpdate(id = Some("foo".toPath), version = Some(Timestamp.now())).onlyVersionOrIdSet)

    intercept[Exception] {
      AppUpdate(cmd = Some("foo"), version = Some(Timestamp.now()))
    }
  }

  test("acceptedResourceRoles of update is only applied when != None") {
    val app = AppDefinition(id = PathId("withAcceptedRoles"), acceptedResourceRoles = Some(Set("a")))

    val unchanged = AppUpdate().apply(app).copy(versionInfo = app.versionInfo)
    assert(unchanged == app)

    val changed = AppUpdate(acceptedResourceRoles = Some(Set("b"))).apply(app).copy(versionInfo = app.versionInfo)
    assert(changed == app.copy(acceptedResourceRoles = Some(Set("b"))))
  }

  test("AppUpdate does not change existing versionInfo") {
    val app = AppDefinition(
      id = PathId("test"),
      cmd = Some("sleep 1"),
      versionInfo = AppDefinition.VersionInfo.forNewConfig(Timestamp(1))
    )

    val updateCmd = AppUpdate(cmd = Some("sleep 2"))
    assert(updateCmd(app) == app)
  }

  test("AppUpdate with a version and other changes are not allowed") {
    val attempt = Try(AppUpdate(id = Some(PathId("/test")), cmd = Some("sleep 2"), version = Some(Timestamp(2))))
    assert(attempt.failed.get.getMessage.contains("The 'version' field may only be combined with the 'id' field."))
  }

  test("update may not have both uris and fetch") {
    val json =
      """
      {
        "id": "app-with-network-isolation",
        "uris": ["http://example.com/file1.tar.gz"],
        "fetch": [{"uri": "http://example.com/file1.tar.gz"}]
      }
      """

    import Formats._
    val result = Json.fromJson[AppUpdate](Json.parse(json))
    assert(result == JsError(ValidationError("You cannot specify both uris and fetch fields")))
  }

  test("update may not have both ports and portDefinitions") {
    val json =
      """
      {
        "id": "app",
        "ports": [1],
        "portDefinitions": [{"port": 2}]
      }
      """

    import Formats._
    val result = Json.fromJson[AppUpdate](Json.parse(json))
    assert(result == JsError(ValidationError("You cannot specify both ports and port definitions")))
  }

  test("update may not have duplicated ports") {
    val json =
      """
      {
        "id": "app",
        "ports": [1, 1]
      }
      """

    import Formats._
    val result = Json.fromJson[AppUpdate](Json.parse(json))
    assert(result == JsError(JsPath \ "ports", ValidationError("Ports must be unique.")))
  }
}


text:
int main() {
  try {
    RtMidiIn midiin;
  } catch (RtMidiError &error) {
    // Handle the exception here
    error.printMessage();
  }
  return 0;
}


text:
base::UdpSocketOpener::UdpSocketOpener(asio::ip::udp::socket& s) : socket_{s}
{
  open_socket(socket_);
}

base::UdpSocketOpener::~UdpSocketOpener()
{
  if (!is_released_)
    close_socket(socket_);
}


text:
namespace content {

ContentBrowserTest::ContentBrowserTest()
    : setup_called_(false) {
#if defined(OS_MACOSX)
  // See comment in InProcessBrowserTest::InProcessBrowserTest().
  base::FilePath content_shell_path;
  CHECK(PathService::Get(base::FILE_EXE, &content_shell_path));
  content_shell_path = content_shell_path.DirName();
  content_shell_path = content_shell_path.Append(
      FILE_PATH_LITERAL("Content Shell.app/Contents/MacOS/Content Shell"));
  CHECK(PathService::Override(base::FILE_EXE, content_shell_path));
#endif
  base::FilePath content_test_data(FILE_PATH_LITERAL("content/test/data"));
  CreateTestServer(content_test_data);
  base::FilePath content_test_data_absolute;
  CHECK(PathService::Get(base::DIR_SOURCE_ROOT, &content_test_data_absolute));
  content_test_data_absolute =
      content_test_data_absolute.Append(content_test_data);
  embedded_test_server()->ServeFilesFromDirectory(content_test_data_absolute);
}

ContentBrowserTest::~ContentBrowserTest() {
  CHECK(setup_called_) << "Overridden SetUp() did not call parent "
                          "implementation, so test not run.";
}

void ContentBrowserTest::SetUp() {
  CommandLine* command_line = CommandLine::ForCurrentProcess();
  command_line->AppendSwitch(switches::kContentBrowserTest);

  SetUpCommandLine(command_line);

#if defined(OS_ANDROID)
  shell_main_delegate_.reset(new ShellMainDelegate);
  shell_main_delegate_->PreSandboxStartup();
  if (command_line->HasSwitch(switches::kSingleProcess)) {
    // We explicitly leak the new ContentRendererClient as we're
    // setting a global that may be used after ContentBrowserTest is
    // destroyed.
    ContentRendererClient* old_client =
        SetRendererClientForTesting(new ShellContentRendererClient());
    // No-one should have set this value before we did.
    DCHECK(!old_client);
  }
#elif defined(OS_MACOSX)
  // See InProcessBrowserTest::PrepareTestCommandLine().
  base::FilePath subprocess_path;
  PathService::Get(base::FILE_EXE, &subprocess_path);
  subprocess_path = subprocess_path.DirName().DirName();
  DCHECK_EQ(subprocess_path.BaseName().value(), "Contents");
  subprocess_path = subprocess_path.Append(
      "Frameworks/Content Shell Helper.app/Contents/MacOS/Content Shell Helper");
  command_line->AppendSwitchPath(switches::kBrowserSubprocessPath,
                                 subprocess_path);
#endif

  // LinuxInputMethodContextFactory has to be initialized.
#if !defined(OS_CHROMEOS) && defined(OS_LINUX)
  ui::InitializeInputMethodForTesting();
#endif

  setup_called_ = true;

  BrowserTestBase::SetUp();
}

void ContentBrowserTest::TearDown() {
  BrowserTestBase::TearDown();

  // LinuxInputMethodContextFactory has to be shutdown.
#if !defined(OS_CHROMEOS) && defined(OS_LINUX)
  ui::ShutdownInputMethodForTesting();
#endif

#if defined(OS_ANDROID)
  shell_main_delegate_.reset();
#endif
}

void ContentBrowserTest::RunTestOnMainThreadLoop() {
  if (!CommandLine::ForCurrentProcess()->HasSwitch(switches::kDumpRenderTree)) {
    CHECK_EQ(Shell::windows().size(), 1u);
    shell_ = Shell::windows()[0];
  }

#if defined(OS_MACOSX)
  // On Mac, without the following autorelease pool, code which is directly
  // executed (as opposed to executed inside a message loop) would autorelease
  // objects into a higher-level pool. This pool is not recycled in-sync with
  // the message loops' pools and causes problems with code relying on
  // deallocation via an autorelease pool (such as browser window closure and
  // browser shutdown). To avoid this, the following pool is recycled after each
  // time code is directly executed.
  base::mac::ScopedNSAutoreleasePool pool;
#endif

  // Pump startup related events.
  base::MessageLoopForUI::current()->RunUntilIdle();

#if defined(OS_MACOSX)
  pool.Recycle();
#endif

  SetUpOnMainThread();

  RunTestOnMainThread();

  TearDownOnMainThread();
#if defined(OS_MACOSX)
  pool.Recycle();
#endif

  for (RenderProcessHost::iterator i(RenderProcessHost::AllHostsIterator());
       !i.IsAtEnd(); i.Advance()) {
    i.GetCurrentValue()->FastShutdownIfPossible();
  }

  Shell::CloseAllWindows();
}

Shell* ContentBrowserTest::CreateBrowser() {
  return Shell::CreateNewWindow(
      ShellContentBrowserClient::Get()->browser_context(),
      GURL(url::kAboutBlankURL),
      NULL,
      MSG_ROUTING_NONE,
      gfx::Size());
}

Shell* ContentBrowserTest::CreateOffTheRecordBrowser() {
  return Shell::CreateNewWindow(
      ShellContentBrowserClient::Get()->off_the_record_browser_context(),
      GURL(url::kAboutBlankURL),
      NULL,
      MSG_ROUTING_NONE,
      gfx::Size());
}

}  // namespace content


text:
'use strict';

module.exports = {
	LISTEN_PORT: 7654,
	MONGO_CONNECTION_STRING: 'mongodb://localhost:27017/chitchat',
	UPLOAD_DIR: 'messages/'
};