/*******************************************************************************
 * Copyright (c) 2000, 2017 IBM Corporation and others.
 *
 * This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License 2.0
 * which accompanies this distribution, and is available at
 * https://www.eclipse.org/legal/epl-2.0/
 *
 * SPDX-License-Identifier: EPL-2.0
 *
 * Contributors:
 *     IBM Corporation - initial API and implementation
 *     Stephan Herrmann - Contributions for
 *								bug 186342 - [compiler][null] Using annotations for null checking
 *								bug 392099 - [1.8][compiler][null] Apply null annotation on types for null analysis
 *								bug 392384 - [1.8][compiler][null] Restore nullness info from type annotations in class files
 *								Bug 415043 - [1.8][null] Follow-up re null type annotations after bug 392099
 *								Bug 417295 - [1.8[[null] Massage type annotated null analysis to gel well with deep encoded type bindings.
 *								Bug 425152 - [1.8] [compiler] Lambda Expression not resolved but flow analyzed leading to NPE.
 *								Bug 429958 - [1.8][null] evaluate new DefaultLocation attribute of @NonNullByDefault
 *******************************************************************************/
package org.eclipse.jdt.internal.compiler.lookup;

import org.eclipse.jdt.internal.compiler.ast.NullAnnotationMatching;
import org.eclipse.jdt.internal.compiler.ast.Wildcard;

/**
 * Binding denoting a method after type parameter substitutions got performed.
 * On parameterized type bindings, all methods got substituted, regardless whether
 * their signature did involve generics or not, so as to get the proper declaringClass for
 * these methods.
 */
public class ParameterizedMethodBinding extends MethodBinding {

	protected MethodBinding originalMethod;

	/**
	 * Create method of parameterized type, substituting original parameters/exception/return type with type arguments.
	 */
	public ParameterizedMethodBinding(final ParameterizedTypeBinding parameterizedDeclaringClass, MethodBinding originalMethod) {
		super(
				originalMethod.modifiers,
				originalMethod.selector,
				originalMethod.returnType,
				originalMethod.parameters,
				originalMethod.thrownExceptions,
				parameterizedDeclaringClass);
		this.originalMethod = originalMethod;
		/* missing type bit cannot be copied as is it might come from the return type or a parameter type that
		 * is substituted by a raw type.
		 */
		this.tagBits = originalMethod.tagBits & ~TagBits.HasMissingType;
		this.parameterNonNullness = originalMethod.parameterNonNullness;
		this.defaultNullness = originalMethod.defaultNullness;

		final TypeVariableBinding[] originalVariables = originalMethod.typeVariables;
		Substitution substitution = null;
		final int length = originalVariables.length;
		final boolean isStatic = originalMethod.isStatic();
		if (length == 0) {
			this.typeVariables = Binding.NO_TYPE_VARIABLES;
			if (!isStatic) substitution = parameterizedDeclaringClass;
		} else {
			// at least fix up the declaringElement binding + bound substitution if non static
			final TypeVariableBinding[] substitutedVariables = new TypeVariableBinding[length];
			for (int i = 0; i < length; i++) { // copy original type variable to relocate
				TypeVariableBinding originalVariable = originalVariables[i];
				substitutedVariables[i] = new TypeVariableBinding(originalVariable.sourceName, this, originalVariable.rank, parameterizedDeclaringClass.environment);
				substitutedVariables[i].tagBits |= (originalVariable.tagBits & (TagBits.AnnotationNullMASK|TagBits.HasNullTypeAnnotation));
			}
			this.typeVariables = substitutedVariables;

			// need to substitute old var refs with new ones (double substitution: declaringClass + new type variables)
			substitution = new Substitution() {
				@Override
				public LookupEnvironment environment() {
					return parameterizedDeclaringClass.environment;
				}
				@Override
				public boolean isRawSubstitution() {
					return !isStatic && parameterizedDeclaringClass.isRawSubstitution();
				}
				@Override
				public TypeBinding substitute(TypeVariableBinding typeVariable) {
					// check this variable can be substituted given copied variables
					if (typeVariable.rank < length && TypeBinding.equalsEquals(originalVariables[typeVariable.rank], typeVariable)) {
						TypeBinding substitute = substitutedVariables[typeVariable.rank];
						return typeVariable.hasTypeAnnotations() ? environment().createAnnotatedType(substitute, typeVariable.getTypeAnnotations()) : substitute;
					}
					if (!isStatic)
						return parameterizedDeclaringClass.substitute(typeVariable);
					return typeVariable;
				}
			};

			// initialize new variable bounds
			for (int i = 0; i < length; i++) {
				TypeVariableBinding originalVariable = originalVariables[i];
				TypeVariableBinding substitutedVariable = substitutedVariables[i];
				TypeBinding substitutedSuperclass = Scope.substitute(substitution, originalVariable.superclass);
				ReferenceBinding[] substitutedInterfaces = Scope.substitute(substitution, originalVariable.superInterfaces);
				if (originalVariable.firstBound != null) {
					TypeBinding firstBound;
					firstBound = TypeBinding.equalsEquals(originalVariable.firstBound, originalVariable.superclass)
						? substitutedSuperclass // could be array type or interface
						: substitutedInterfaces[0];
					substitutedVariable.setFirstBound(firstBound);
				}
				switch (substitutedSuperclass.kind()) {
					case Binding.ARRAY_TYPE :
						substitutedVariable.setSuperClass(parameterizedDeclaringClass.environment.getResolvedJavaBaseType(TypeConstants.JAVA_LANG_OBJECT, null));
						substitutedVariable.setSuperInterfaces(substitutedInterfaces);
						break;
					default:
						if (substitutedSuperclass.isInterface()) {
							substitutedVariable.setSuperClass(parameterizedDeclaringClass.environment.getResolvedType(TypeConstants.JAVA_LANG_OBJECT, null));
							int interfaceCount = substitutedInterfaces.length;
							System.arraycopy(substitutedInterfaces, 0, substitutedInterfaces = new ReferenceBinding[interfaceCount+1], 1, interfaceCount);
							substitutedInterfaces[0] = (ReferenceBinding) substitutedSuperclass;
							substitutedVariable.setSuperInterfaces(substitutedInterfaces);
						} else {
							substitutedVariable.setSuperClass((ReferenceBinding) substitutedSuperclass); // typeVar was extending other typeVar which got substituted with interface
							substitutedVariable.setSuperInterfaces(substitutedInterfaces);
						}
				}
			}
		}
		if (substitution != null) {
			this.returnType = Scope.substitute(substitution, this.returnType);
			this.parameters = Scope.substitute(substitution, this.parameters);
			this.thrownExceptions = Scope.substitute(substitution, this.thrownExceptions);
			// error case where exception type variable would have been substituted by a non-reference type (207573)
			if (this.thrownExceptions == null) this.thrownExceptions = Binding.NO_EXCEPTIONS;

			// after substitution transfer nullness information from type annotations:
			if (parameterizedDeclaringClass.environment.globalOptions.isAnnotationBasedNullAnalysisEnabled) {
				long returnNullBits = NullAnnotationMatching.validNullTagBits(this.returnType.tagBits);
				if (returnNullBits != 0L) {
					this.tagBits &= ~TagBits.AnnotationNullMASK;
					this.tagBits |= returnNullBits;
				}
				int parametersLen = this.parameters.length;
				for (int i=0; i<parametersLen; i++) {
					long paramTagBits = NullAnnotationMatching.validNullTagBits(this.parameters[i].tagBits);
					if (paramTagBits != 0) {
						if (this.parameterNonNullness == null)
							this.parameterNonNullness = new Boolean[parametersLen];
						this.parameterNonNullness[i] = Boolean.valueOf(paramTagBits == TagBits.AnnotationNonNull);
					}
				}
			}
		}
		checkMissingType: {
			if ((this.tagBits & TagBits.HasMissingType) != 0)
				break checkMissingType;
			if ((this.returnType.tagBits & TagBits.HasMissingType) != 0) {
				this.tagBits |=  TagBits.HasMissingType;
				break checkMissingType;
			}
			for (int i = 0, max = this.parameters.length; i < max; i++) {
				if ((this.parameters[i].tagBits & TagBits.HasMissingType) != 0) {
					this.tagBits |=  TagBits.HasMissingType;
					break checkMissingType;
				}
			}
			for (int i = 0, max = this.thrownExceptions.length; i < max; i++) {
				if ((this.thrownExceptions[i].tagBits & TagBits.HasMissingType) != 0) {
					this.tagBits |=  TagBits.HasMissingType;
					break checkMissingType;
				}
			}
		}
	}

	/**
	 * Create method of parameterized type, substituting original parameters/exception/return type with type arguments.
	 * This is a CODE ASSIST method ONLY.
	 */
	public ParameterizedMethodBinding(final ReferenceBinding declaringClass, MethodBinding originalMethod, char[][] alternateParamaterNames, final LookupEnvironment environment) {
		super(
				originalMethod.modifiers,
				originalMethod.selector,
				 originalMethod.returnType,
				originalMethod.parameters,
				originalMethod.thrownExceptions,
				declaringClass);
		this.originalMethod = originalMethod;
		/* missing type bit cannot be copied as is it might come from the return type or a parameter type that
		 * is substituted by a raw type.
		 */
		this.tagBits = originalMethod.tagBits & ~TagBits.HasMissingType;
		this.parameterNonNullness = originalMethod.parameterNonNullness;
		this.defaultNullness = originalMethod.defaultNullness;

		final TypeVariableBinding[] originalVariables = originalMethod.typeVariables;
		Substitution substitution = null;
		final int length = originalVariables.length;
		if (length == 0) {
			this.typeVariables = Binding.NO_TYPE_VARIABLES;
		} else {
			// at least fix up the declaringElement binding + bound substitution if non static
			final TypeVariableBinding[] substitutedVariables = new TypeVariableBinding[length];
			for (int i = 0; i < length; i++) { // copy original type variable to relocate
				TypeVariableBinding originalVariable = originalVariables[i];
				substitutedVariables[i] = new TypeVariableBinding(
						alternateParamaterNames == null ?
								originalVariable.sourceName :
								alternateParamaterNames[i],
							this,
							originalVariable.rank,
							environment);
				substitutedVariables[i].tagBits |= (originalVariable.tagBits & (TagBits.AnnotationNullMASK|TagBits.HasNullTypeAnnotation));
			}
			this.typeVariables = substitutedVariables;

			// need to substitute old var refs with new ones (double substitution: declaringClass + new type variables)
			substitution = new Substitution() {
				@Override
				public LookupEnvironment environment() {
					return environment;
				}
				@Override
				public boolean isRawSubstitution() {
					return false;
				}
				@Override
				public TypeBinding substitute(TypeVariableBinding typeVariable) {
			        // check this variable can be substituted given copied variables
			        if (typeVariable.rank < length && TypeBinding.equalsEquals(originalVariables[typeVariable.rank], typeVariable)) {
			        	TypeBinding substitute = substitutedVariables[typeVariable.rank];
						return typeVariable.hasTypeAnnotations() ? environment().createAnnotatedType(substitute, typeVariable.getTypeAnnotations()) : substitute;
			        }
			        return typeVariable;
				}
			};

			// initialize new variable bounds
			for (int i = 0; i < length; i++) {
				TypeVariableBinding originalVariable = originalVariables[i];
				TypeVariableBinding substitutedVariable = substitutedVariables[i];
				TypeBinding substitutedSuperclass = Scope.substitute(substitution, originalVariable.superclass);
				ReferenceBinding[] substitutedInterfaces = Scope.substitute(substitution, originalVariable.superInterfaces);
				if (originalVariable.firstBound != null) {
					TypeBinding firstBound;
					firstBound = TypeBinding.equalsEquals(originalVariable.firstBound, originalVariable.superclass)
						? substitutedSuperclass // could be array type or interface
						: substitutedInterfaces[0];
					substitutedVariable.setFirstBound(firstBound);
				}
				switch (substitutedSuperclass.kind()) {
					case Binding.ARRAY_TYPE :
						substitutedVariable.setSuperClass(environment.getResolvedJavaBaseType(TypeConstants.JAVA_LANG_OBJECT, null));
						substitutedVariable.setSuperInterfaces(substitutedInterfaces);
						break;
					default:
						if (substitutedSuperclass.isInterface()) {
							substitutedVariable.setSuperClass(environment.getResolvedType(TypeConstants.JAVA_LANG_OBJECT, null));
							int interfaceCount = substitutedInterfaces.length;
							System.arraycopy(substitutedInterfaces, 0, substitutedInterfaces = new ReferenceBinding[interfaceCount+1], 1, interfaceCount);
							substitutedInterfaces[0] = (ReferenceBinding) substitutedSuperclass;
							substitutedVariable.setSuperInterfaces(substitutedInterfaces);
						} else {
							substitutedVariable.setSuperClass((ReferenceBinding) substitutedSuperclass); // typeVar was extending other typeVar which got substituted with interface
							substitutedVariable.setSuperInterfaces(substitutedInterfaces);
						}
				}
			}
		}
		if (substitution != null) {
			this.returnType = Scope.substitute(substitution, this.returnType);
			this.parameters = Scope.substitute(substitution, this.parameters);
			this.thrownExceptions = Scope.substitute(substitution, this.thrownExceptions);
		    // error case where exception type variable would have been substituted by a non-reference type (207573)
		    if (this.thrownExceptions == null) this.thrownExceptions = Binding.NO_EXCEPTIONS;
		}
		checkMissingType: {
			if ((this.tagBits & TagBits.HasMissingType) != 0)
				break checkMissingType;
			if ((this.returnType.tagBits & TagBits.HasMissingType) != 0) {
				this.tagBits |=  TagBits.HasMissingType;
				break checkMissingType;
			}
			for (int i = 0, max = this.parameters.length; i < max; i++) {
				if ((this.parameters[i].tagBits & TagBits.HasMissingType) != 0) {
					this.tagBits |=  TagBits.HasMissingType;
					break checkMissingType;
				}
			}
			for (int i = 0, max = this.thrownExceptions.length; i < max; i++) {
				if ((this.thrownExceptions[i].tagBits & TagBits.HasMissingType) != 0) {
					this.tagBits |=  TagBits.HasMissingType;
					break checkMissingType;
				}
			}
		}
	}

	public ParameterizedMethodBinding() {
		// no init
	}

	/**
	 * The type of x.getClass() is substituted from 'Class<? extends Object>' into: 'Class<? extends raw(X)>
	 */
	public static ParameterizedMethodBinding instantiateGetClass(TypeBinding receiverType, MethodBinding originalMethod, Scope scope) {
		ParameterizedMethodBinding method = new ParameterizedMethodBinding();
		method.modifiers = originalMethod.modifiers;
		method.selector = originalMethod.selector;
		method.declaringClass = originalMethod.declaringClass;
		method.typeVariables = Binding.NO_TYPE_VARIABLES;
		method.originalMethod = originalMethod;
		method.parameters = originalMethod.parameters;
		method.thrownExceptions = originalMethod.thrownExceptions;
		method.tagBits = originalMethod.tagBits;
		ReferenceBinding genericClassType = scope.getJavaLangClass();
		LookupEnvironment environment = scope.environment();
		TypeBinding rawType = environment.convertToRawType(receiverType.erasure(), false /*do not force conversion of enclosing types*/);
		if (environment.usesNullTypeAnnotations())
			rawType = environment.createAnnotatedType(rawType, new AnnotationBinding[] { environment.getNonNullAnnotation() });
		method.returnType = environment.createParameterizedType(
			genericClassType,
			new TypeBinding[] {  environment.createWildcard(genericClassType, 0, rawType, null /*no extra bound*/, Wildcard.EXTENDS) },
			null);
		if (environment.globalOptions.isAnnotationBasedNullAnalysisEnabled) {
			if (environment.usesNullTypeAnnotations())
				method.returnType = environment.createAnnotatedType(method.returnType, new AnnotationBinding[] { environment.getNonNullAnnotation() });
			else
				method.tagBits |= TagBits.AnnotationNonNull;
		}
		if ((method.returnType.tagBits & TagBits.HasMissingType) != 0) {
			method.tagBits |=  TagBits.HasMissingType;
		}
		return method;
	}

	/**
	 * Returns true if some parameters got substituted.
	 */
	@Override
	public boolean hasSubstitutedParameters() {
		return this.parameters != this.originalMethod.parameters;
	}

	/**
	 * Returns true if the return type got substituted.
	 */
	@Override
	public boolean hasSubstitutedReturnType() {
		return this.returnType != this.originalMethod.returnType; //$IDENTITY-COMPARISON$
	}

	/**
	 * Returns the original method (as opposed to parameterized instances)
	 */
	@Override
	public MethodBinding original() {
		return this.originalMethod.original();
	}

	@Override
	public MethodBinding shallowOriginal() {
		return this.originalMethod;
	}
}


import { CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
import { async, ComponentFixture, TestBed } from '@angular/core/testing';
import { MessageTemplatePage } from './message-template.page';

describe('MessageTemplatePage', () => {
  let component: MessageTemplatePage;
  let fixture: ComponentFixture<MessageTemplatePage>;

  beforeEach(async(() => {
    TestBed.configureTestingModule({
      declarations: [MessageTemplatePage],
      schemas: [CUSTOM_ELEMENTS_SCHEMA],
    })
      .compileComponents();
  }));

  beforeEach(() => {
    fixture = TestBed.createComponent(MessageTemplatePage);
    component = fixture.componentInstance;
    fixture.detectChanges();
  });

  it('should create', () => {
    expect(component).toBeTruthy();
  });
});


/*!
 * @license
 * Copyright 2019 Alfresco Software, Ltd.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

import { BrowserVisibility } from '../utils/browser-visibility';
import { element, by } from 'protractor';
import { BrowserActions } from '../utils/browser-actions';

export class ErrorPage {

    errorPageCode = element(by.css('adf-error-content .adf-error-content-code'));
    errorPageTitle = element(by.css('adf-error-content .adf-error-content-title'));
    errorPageDescription = element(by.css('adf-error-content .adf-error-content-description'));

    async checkErrorCode(): Promise<void> {
        await BrowserVisibility.waitUntilElementIsVisible(this.errorPageCode);
    }

    async getErrorCode(): Promise<string> {
        return BrowserActions.getText(this.errorPageCode);
    }

    async getErrorTitle(): Promise<string> {
        return BrowserActions.getText(this.errorPageTitle);
    }

    async getErrorDescription(): Promise<string> {
        return BrowserActions.getText(this.errorPageDescription);
    }
}


Aggiungi al dizionario

Aggiungi al dizionario personale

Aggiungi "$1" al dizionario

Avanzate

alt

Alt Gr

Molto elevata

Pagina Impostazioni tastiera fonetica Armeno

Google Japanese Input (for Japanese keyboard)

Google Japanese Input (for US keyboard)

Correzione automatica

backspace

Opzioni di base

Pagina Impostazioni tastiera Belga (francese)

Pagina Impostazioni tastiera Belga (tedesco)

Pagina Impostazioni tastiera Belga (olandese)

Pagina Impostazioni tastiera Bulgaro

Pagina Impostazioni tastiera fonetica Bulgaro

Pagina Impostazioni tastiera Brasiliano (portoghese brasiliano)

Pagina Impostazioni tastiera Bielorusso

Pagina Impostazioni tastiera Inglese canadese (inglese)

Pagina Impostazioni tastiera Francese canadese (francese)

Pagina Impostazioni tastiera multilingue Canadese (francese)

maiuscolo

bloc maiusc

Pagina Impostazioni tastiera Francese svizzero (francese)

Pagina Impostazioni tastiera Svizzero (tedesco)

Google Strumenti di immissione per Chrome OS consente di digitare del testo nella lingua che preferisci in Chrome OS.

Google Strumenti di immissione

Direct input

Wide Latin

Katakana

Latin

Half width katakana

Hiragana

Basics

Clear personalization data...

Cancel

Conversion history

Obliterate the following items:

Clear personalization data

Suggestion history

Clear personalization data

Copyright © 2013 Google Inc. All Rights Reserved.

Cancel

OK

Manage user dictionary...

Add your own words to the user dictionary in order to customize the conversion candidates.

User dictionaries

Disable personalized conversions and suggestions as well as user dictionary

Input assistance

This software is made possible by open source software.

Input mode:

Kana

Romaji

Privacy

Punctuation style:

Selection shortcut:

No shortcut

Keymap style:

ATOK

Chrome OS

Custom keymap

Kotoeri

MS-IME

Japanese input settings

Shift key mode switch:

Alphanumeric

Katakana

Off

Space input style:

Follow input mode

Fullwidth

Halfwidth

Number of suggestions:

Suggest

Symbol style:

Automatically send usage statistics and crash reports to Google

Automatically switch to halfwidth

Use system dictionary

Use input history

ctrl

tastiera attualmente selezionata

La lingua di inserimento è il cinese

La larghezza della punteggiatura è piena

La larghezza dei caratteri è piena

Pagina Impostazioni tastiera Ceco

Pagina Impostazioni tastiera QWERTY Ceco

MAHJONG TILE RED DRAGON

PLAYING CARD BLACK JOKER

NEGATIVE SQUARED LATIN CAPITAL LETTER A

NEGATIVE SQUARED LATIN CAPITAL LETTER B

NEGATIVE SQUARED LATIN CAPITAL LETTER O

NEGATIVE SQUARED LATIN CAPITAL LETTER P

NEGATIVE SQUARED AB

SQUARED CL

SQUARED COOL

SQUARED FREE

SQUARED ID

SQUARED NEW

SQUARED NG

SQUARED OK

SQUARED SOS

SQUARED UP WITH EXCLAMATION MARK

SQUARED VS

Parola giapponese "qui"

Parola giapponese "servizio"

Parola giapponese "gratis"

Parola giapponese "prenotato"

Parola giapponese "vietato"

Parola cinese "spazio disponibile"

Parola cinese "consenso"

Parola cinese "completo"

Parola giapponese "tariffe"

Parola giapponese "mensile"

Parola cinese"richiesta"

Parola giapponese "sconto"

Parola cinese "in funzione"

Parola giapponese "vantaggio"

Parola cinese "approvato"

CYCLONE

FOGGY

CLOSED UMBRELLA

NIGHT WITH STARS

alba sulle montagne

SUNRISE

CITYSCAPE AT DUSK

SUNSET OVER BUILDINGS

RAINBOW

BRIDGE AT NIGHT

WATER WAVE

VOLCANO

MILKY WAY

globo Europa-Africa

globo Americhe

globo Asia-Australia

globo con meridiani

NEW MOON SYMBOL

luna crescente

primo quarto di luna

WAXING GIBBOUS MOON SYMBOL

FULL MOON SYMBOL

WANING GIBBOUS MOON SYMBOL

ultimo quarto di luna

luna calante

CRESCENT MOON

NEW MOON WITH FACE

faccina primo quarto di luna

faccina ultimo quarto di luna

FULL MOON WITH FACE

SUN WITH FACE

GLOWING STAR

SHOOTING STAR

CHESTNUT

SEEDLING

EVERGREEN TREE

DECIDUOUS TREE

PALM TREE

CACTUS

TULIP

CHERRY BLOSSOM

ROSE

HIBISCUS

SUNFLOWER

BLOSSOM

EAR OF MAIZE

EAR OF RICE

HERB

FOUR LEAF CLOVER

MAPLE LEAF

FALLEN LEAF

LEAF FLUTTERING IN WIND

MUSHROOM

TOMATO

AUBERGINE

GRAPES

MELON

WATERMELON

TANGERINE

LEMON

BANANA

PINEAPPLE

RED APPLE

GREEN APPLE

PEAR

PEACH

CHERRIES

STRAWBERRY

HAMBURGER

SLICE OF PIZZA

MEAT ON BONE

POULTRY LEG

RICE CRACKER

RICE BALL

COOKED RICE

CURRY AND RICE

STEAMING BOWL

SPAGHETTI

BREAD

FRENCH FRIES

ROASTED SWEET POTATO

DANGO

ODEN

SUSHI

FRIED SHRIMP

FISH CAKE WITH SWIRL DESIGN

SOFT ICE CREAM

SHAVED ICE

ICE CREAM

DOUGHNUT

COOKIE

CHOCOLATE BAR

CANDY

LOLLIPOP

CUSTARD

HONEY POT

SHORTCAKE

BENTO BOX

POT OF FOOD

COOKING

FORK AND KNIFE

TEACUP WITHOUT HANDLE

SAKE BOTTLE AND CUP

WINE GLASS

COCKTAIL GLASS

TROPICAL DRINK

BEER MUG

CLINKING BEER MUGS

BABY BOTTLE

RIBBON

WRAPPED PRESENT

BIRTHDAY CAKE

JACK-O-LANTERN

CHRISTMAS TREE

FATHER CHRISTMAS

FIREWORKS

FIREWORK SPARKLER

BALLOON

PARTY POPPER

CONFETTI BALL

TANABATA TREE

CROSSED FLAGS

PINE DECORATION

JAPANESE DOLLS

CARP STREAMER

WIND CHIME

MOON VIEWING CEREMONY

SCHOOL SATCHEL

GRADUATION CAP

CAROUSEL HORSE

FERRIS WHEEL

ROLLER COASTER

FISHING POLE AND FISH

MICROPHONE

MOVIE CAMERA

CINEMA

HEADPHONE

ARTIST PALETTE

TOP HAT

CIRCUS TENT

TICKET

CLAPPER BOARD

PERFORMING ARTS

VIDEO GAME

DIRECT HIT

SLOT MACHINE

BILLIARDS

GAME DIE

BOWLING

FLOWER PLAYING CARDS

MUSICAL NOTE

MULTIPLE MUSICAL NOTES

SAXOPHONE

GUITAR

MUSICAL KEYBOARD

TRUMPET

VIOLIN

MUSICAL SCORE

RUNNING SHIRT WITH SASH

TENNIS RACQUET AND BALL

SKI AND SKI BOOT

BASKETBALL AND HOOP

CHEQUERED FLAG

SNOWBOARDER

RUNNER

SURFER

TROPHY

HORSE RACING

AMERICAN FOOTBALL

RUGBY FOOTBALL

SWIMMER

HOUSE BUILDING

HOUSE WITH GARDEN

OFFICE BUILDING

ufficio postale giapponese

ufficio postale europeo

HOSPITAL

BANK

AUTOMATED TELLER MACHINE

HOTEL

LOVE HOTEL

CONVENIENCE STORE

SCHOOL

DEPARTMENT STORE

FACTORY

IZAKAYA LANTERN

JAPANESE CASTLE

EUROPEAN CASTLE

RAT

MOUSE

OX

WATER BUFFALO

COW

LEOPARD

RABBIT

CAT

DRAGON

CROCODILE

WHALE

SNAIL

SNAKE

HORSE

RAM

GOAT

SHEEP

MONKEY

ROOSTER

CHICKEN

DOG

PIG

BOAR

ELEPHANT

OCTOPUS

SPIRAL SHELL

BUG

ANT

HONEYBEE

LADY BEETLE

FISH

TROPICAL FISH

BLOWFISH

TURTLE

HATCHING CHICK

faccina pulcino

FRONT-FACING BABY CHICK

BIRD

PENGUIN

KOALA

POODLE

DROMEDARY CAMEL

BACTRIAN CAMEL

DOLPHIN

MOUSE FACE

COW FACE

TIGER FACE

RABBIT FACE

CAT FACE

DRAGON FACE

SPOUTING WHALE

HORSE FACE

MONKEY FACE

DOG FACE

PIG FACE

FROG FACE

HAMSTER FACE

WOLF FACE

BEAR FACE

PANDA FACE

PIG NOSE

PAW PRINTS

occhi

EAR

NOSE

MOUTH

TONGUE

WHITE UP POINTING BACKHAND INDEX

WHITE DOWN POINTING BACKHAND INDEX

WHITE LEFT POINTING BACKHAND INDEX

WHITE RIGHT POINTING BACKHAND INDEX

FISTED HAND SIGN

WAVING HAND SIGN

mano che fa OK

THUMBS UP SIGN

THUMBS DOWN SIGN

CLAPPING HANDS SIGN

OPEN HANDS SIGN

CROWN

WOMANS HAT

EYEGLASSES

NECKTIE

T-SHIRT

JEANS

DRESS

KIMONO

BIKINI

WOMANS CLOTHES

PURSE

HANDBAG

POUCH

MANS SHOE

ATHLETIC SHOE

HIGH-HEELED SHOE

WOMANS SANDAL

WOMANS BOOTS

FOOTPRINTS

BUST IN SILHOUETTE

BUSTS IN SILHOUETTE

BOY

GIRL

MAN

WOMAN

FAMILY

MAN AND WOMAN HOLDING HANDS

TWO MEN HOLDING HANDS

TWO WOMEN HOLDING HANDS

POLICE OFFICER

WOMAN WITH BUNNY EARS

BRIDE WITH VEIL

PERSON WITH BLOND HAIR

uomo con zucchetto

uomo con turbante

OLDER MAN

OLDER WOMAN

BABY

CONSTRUCTION WORKER

PRINCESS

JAPANESE OGRE

JAPANESE GOBLIN

GHOST

BABY ANGEL

EXTRATERRESTRIAL ALIEN

ALIEN MONSTER

IMP

SKULL

INFORMATION DESK PERSON

GUARDSMAN

DANCER

LIPSTICK

NAIL POLISH

FACE MASSAGE

HAIRCUT

BARBER POLE

SYRINGE

PILL

KISS MARK

LOVE LETTER

RING

GEM STONE

KISS

BOUQUET

COUPLE WITH HEART

WEDDING

BEATING HEART

BROKEN HEART

TWO HEARTS

SPARKLING HEART

GROWING HEART

HEART WITH ARROW

BLUE HEART

GREEN HEART

YELLOW HEART

PURPLE HEART

HEART WITH RIBBON

REVOLVING HEARTS

HEART DECORATION

DIAMOND SHAPE WITH A DOT INSIDE

ELECTRIC LIGHT BULB

ANGER SYMBOL

BOMB

simbolo del sonno

COLLISION SYMBOL

SPLASHING SWEAT SYMBOL

DROPLET

DASH SYMBOL

PILE OF POO

FLEXED BICEPS

DIZZY SYMBOL

SPEECH BALLOON

THOUGHT BALLOON

WHITE FLOWER

HUNDRED POINTS SYMBOL

MONEY BAG

CURRENCY EXCHANGE

HEAVY DOLLAR SIGN

CREDIT CARD

BANKNOTE WITH YEN SIGN

BANKNOTE WITH DOLLAR SIGN

BANKNOTE WITH EURO SIGN

BANKNOTE WITH POUND SIGN

MONEY WITH WINGS

CHART WITH UPWARDS TREND AND YEN SIGN

SEAT

PERSONAL COMPUTER

BRIEFCASE

mini disc

FLOPPY DISK

OPTICAL DISC

DVD

FILE FOLDER

OPEN FILE FOLDER

PAGE WITH CURL

PAGE FACING UP

CALENDAR

TEAR-OFF CALENDAR

CARD INDEX

CHART WITH UPWARDS TREND

CHART WITH DOWNWARDS TREND

BAR CHART

CLIPBOARD

PUSHPIN

ROUND PUSHPIN

PAPERCLIP

STRAIGHT RULER

TRIANGULAR RULER

BOOKMARK TABS

LEDGER

NOTEBOOK

NOTEBOOK WITH DECORATIVE COVER

CLOSED BOOK

OPEN BOOK

GREEN BOOK

BLUE BOOK

ORANGE BOOK

BOOKS

NAME BADGE

SCROLL

MEMO

TELEPHONE RECEIVER

PAGER

FAX MACHINE

SATELLITE ANTENNA

PUBLIC ADDRESS LOUDSPEAKER

CHEERING MEGAPHONE

OUTBOX TRAY

INBOX TRAY

PACKAGE

E-MAIL SYMBOL

INCOMING ENVELOPE

ENVELOPE WITH DOWNWARDS ARROW ABOVE

cassetta postale chiusa  bandierina giù

cassetta postale chiusa  bandierina su

cassetta postale aperta bandierina su

cassetta postale aperta bandierina giù

POSTBOX

POSTAL HORN

NEWSPAPER

MOBILE PHONE

MOBILE PHONE WITH RIGHTWARDS ARROW AT LEFT

VIBRATION MODE

MOBILE PHONE OFF

NO MOBILE PHONES

ANTENNA WITH BARS

CAMERA

VIDEO CAMERA

TELEVISION

RADIO

VIDEOCASSETTE

TWISTED RIGHTWARDS ARROWS

CLOCKWISE RIGHTWARDS AND LEFTWARDS OPEN CIRCLE ARROWS WITH CIRCLED ONE OVERLAY

ANTICLOCKWISE DOWNWARDS AND UPWARDS OPEN CIRCLE ARROWS

LOW BRIGHTNESS SYMBOL

HIGH BRIGHTNESS SYMBOL

SPEAKER WITH CANCELLATION STROKE

SPEAKER

altoparlante volume basso

altoparlante volume alto

BATTERY

ELECTRIC PLUG

lente ingrandimento verso sinistra

lente ingrandimento verso destra

lucchetto con penna stilo

lucchetto chiuso con chiave

KEY

lucchetto chiuso

lucchetto aperto

BELL

BELL WITH CANCELLATION STROKE

BOOKMARK

LINK SYMBOL

RADIO BUTTON

BACK WITH LEFTWARDS ARROW ABOVE

END WITH LEFTWARDS ARROW ABOVE

ON WITH EXCLAMATION MARK WITH LEFT RIGHT ARROW ABOVE

SOON WITH RIGHTWARDS ARROW ABOVE

TOP WITH UPWARDS ARROW ABOVE

NO ONE UNDER EIGHTEEN SYMBOL

INPUT SYMBOL FOR LATIN CAPITAL LETTERS

INPUT SYMBOL FOR LATIN SMALL LETTERS

INPUT SYMBOL FOR NUMBERS

INPUT SYMBOL FOR SYMBOLS

INPUT SYMBOL FOR LATIN LETTERS

FIRE

ELECTRIC TORCH

WRENCH

HAMMER

NUT AND BOLT

HOCHO

PISTOL

MICROSCOPE

TELESCOPE

CRYSTAL BALL

SIX POINTED STAR WITH MIDDLE DOT

JAPANESE SYMBOL FOR BEGINNER

TRIDENT EMBLEM

pulsante quadrato pieno

pulsante quadrato con contorno

cerchio rosso grande

cerchio blu grande

rombo arancione grande

rombo blu grande

rombo arancione piccolo

rombo blu piccolo

UP-POINTING RED TRIANGLE

DOWN-POINTING RED TRIANGLE

pulsante triangolo alto

pulsante triangolo basso

CLOCK FACE ONE OCLOCK

CLOCK FACE TWO OCLOCK

CLOCK FACE THREE OCLOCK

CLOCK FACE FOUR OCLOCK

CLOCK FACE FIVE OCLOCK

CLOCK FACE SIX OCLOCK

CLOCK FACE SEVEN OCLOCK

CLOCK FACE EIGHT OCLOCK

CLOCK FACE NINE OCLOCK

CLOCK FACE TEN OCLOCK

CLOCK FACE ELEVEN OCLOCK

CLOCK FACE TWELVE OCLOCK

CLOCK FACE ONE-THIRTY

CLOCK FACE TWO-THIRTY

CLOCK FACE THREE-THIRTY

CLOCK FACE FOUR-THIRTY

CLOCK FACE FIVE-THIRTY

CLOCK FACE SIX-THIRTY

CLOCK FACE SEVEN-THIRTY

CLOCK FACE EIGHT-THIRTY

CLOCK FACE NINE-THIRTY

CLOCK FACE TEN-THIRTY

CLOCK FACE ELEVEN-THIRTY

CLOCK FACE TWELVE-THIRTY

MOUNT FUJI

TOKYO TOWER

STATUE OF LIBERTY

SILHOUETTE OF JAPAN

MOYAI

GRINNING FACE

sogghigno con occhi felici

FACE WITH TEARS OF JOY

SMILING FACE WITH OPEN MOUTH

sorriso a bocca aperta con occhi  felici

SMILING FACE WITH OPEN MOUTH AND COLD SWEAT

sorriso a bocca aperta con occhi  chiusi

SMILING FACE WITH HALO

SMILING FACE WITH HORNS

WINKING FACE

SMILING FACE WITH SMILING EYES

FACE SAVOURING DELICIOUS FOOD

RELIEVED FACE

SMILING FACE WITH HEART-SHAPED EYES

SMILING FACE WITH SUNGLASSES

SMIRKING FACE

NEUTRAL FACE

EXPRESSIONLESS FACE

UNAMUSED FACE

FACE WITH COLD SWEAT

PENSIVE FACE

CONFUSED FACE

CONFOUNDED FACE

KISSING FACE

FACE THROWING A KISS

KISSING FACE WITH SMILING EYES

KISSING FACE WITH CLOSED EYES

FACE WITH STUCK-OUT TONGUE

lingua fuori con occhiolino

FACE WITH STUCK-OUT TONGUE AND TIGHTLY-CLOSED EYES

DISAPPOINTED FACE

WORRIED FACE

ANGRY FACE

POUTING FACE

CRYING FACE

PERSEVERING FACE

FACE WITH LOOK OF TRIUMPH

DISAPPOINTED BUT RELIEVED FACE

FROWNING FACE WITH OPEN MOUTH

ANGUISHED FACE

FEARFUL FACE

WEARY FACE

SLEEPY FACE

TIRED FACE

GRIMACING FACE

LOUDLY CRYING FACE

FACE WITH OPEN MOUTH

HUSHED FACE

FACE WITH OPEN MOUTH AND COLD SWEAT

FACE SCREAMING IN FEAR

ASTONISHED FACE

FLUSHED FACE

SLEEPING FACE

DIZZY FACE

FACE WITHOUT MOUTH

FACE WITH MEDICAL MASK

GRINNING CAT FACE WITH SMILING EYES

gatto lacrime di gioia

SMILING CAT FACE WITH OPEN MOUTH

SMILING CAT FACE WITH HEART-SHAPED EYES

CAT FACE WITH WRY SMILE

KISSING CAT FACE WITH CLOSED EYES

POUTING CAT FACE

CRYING CAT FACE

WEARY CAT FACE

FACE WITH NO GOOD GESTURE

FACE WITH OK GESTURE

PERSON BOWING DEEPLY

SEE-NO-EVIL MONKEY

HEAR-NO-EVIL MONKEY

SPEAK-NO-EVIL MONKEY

HAPPY PERSON RAISING ONE HAND

PERSON RAISING BOTH HANDS IN CELEBRATION

persona corrucciata

PERSON WITH POUTING FACE

PERSON WITH FOLDED HANDS

ROCKET

HELICOPTER

STEAM LOCOMOTIVE

RAILWAY CAR

HIGH-SPEED TRAIN

treno alta velocità punta  arrotondata

TRAIN

METRO

LIGHT RAIL

STATION

TRAM

TRAM CAR

BUS

ONCOMING BUS

TROLLEYBUS

BUS STOP

MINIBUS

AMBULANCE

FIRE ENGINE

POLICE CAR

ONCOMING POLICE CAR

TAXI

ONCOMING TAXI

AUTOMOBILE

ONCOMING AUTOMOBILE

RECREATIONAL VEHICLE

DELIVERY TRUCK

ARTICULATED LORRY

TRACTOR

MONORAIL

MOUNTAIN RAILWAY

SUSPENSION RAILWAY

MOUNTAIN CABLEWAY

AERIAL TRAMWAY

SHIP

ROWBOAT

SPEEDBOAT

semaforo orizzontale

semaforo verticale

CONSTRUCTION SIGN

POLICE CARS REVOLVING LIGHT

TRIANGULAR FLAG ON POST

DOOR

NO ENTRY SIGN

SMOKING SYMBOL

NO SMOKING SYMBOL

PUT LITTER IN ITS PLACE SYMBOL

DO NOT LITTER SYMBOL

POTABLE WATER SYMBOL

NON-POTABLE WATER SYMBOL

BICYCLE

NO BICYCLES

BICYCLIST

MOUNTAIN BICYCLIST

PEDESTRIAN

NO PEDESTRIANS

CHILDREN CROSSING

MENS SYMBOL

WOMENS SYMBOL

RESTROOM

BABY SYMBOL

TOILET

WATER CLOSET

SHOWER

BATH

BATHTUB

PASSPORT CONTROL

CUSTOMS

BAGGAGE CLAIM

LEFT LUGGAGE

Pagina Impostazioni tastiera Tedesco

Pagina Impostazioni tastiera Neo 2 Tedesco

Category

Comment

Comment

Do you want to delete [object Object]?

Delete dictionary

Dictionaries

Dictionary Name

Done

Export

Import...

Dictionary management

New dictionary

User dictionaries

New reading

Reading

The name contains invalid character(s).

The name already exists.

Please type a dictionary name.

The name is too long.

Can't create any more dictionaries.

The file is empty.

Can't create any more entries in this dictionary.

Could not open the file.

The data size exceeds the file size limit.

The operation has failed.

Some words could not be imported.

The import source contains too many words.

Could not read the file.

No more undo-able operation.

The reading contains invalid character(s). You can use use ASCII characters, Hiragana, voiced sound mark(゛), semi-voiced sound mark(゜), middle dot(・), prolonged sound mark(ー), Japanese comma(、), Japanese period(。), Japanese brackets(「」『』) and Japanese wavedash(〜) in the reading.

Please type the reading.

The reading is too long.

Add entry error

Create dictionary error

Delete dictionary error

Delete entry error

Edit entry error

Import error

Rename dictionary error

The word contains invalid character(s).

Please type the word.

The word is too long.

New word

Word

chiudi menu tastiera

Pagina Impostazioni tastiera Danese

Doppio spazio per digitare il punto

freccia giù

Trascina per spostare la tastiera virtuale

Pagina Impostazioni tastiera Estone

Categoria di emoji Emoticon

Categoria di emoji Faccine

Categoria di emoji Più usate

Categoria di emoji Natura

Categoria di emoji Oggetti

Categoria di emoji Luoghi

Categoria di emoji Recenti

Categoria di emoji Simboli

Maiuscole automatiche

Attiva completamento

Abilita gesti di scorrimento

Scorri dai lati della tastiera per muovere il cursore o dal tasto backspace per eliminare intere parole

Abilita digitazione gestuale

Inserisci una parola scorrendo tra le lettere

Attiva previsione della parola seguente

invio

Pagina Impostazioni tastiera Catalano

Pagina Impostazioni tastiera Spagnolo

Espandi

espandi elenco candidati

Pagina Impostazioni tastiera Finlandese

Pagina Impostazioni tastiera Faroese

aggancia tastiera virtuale

passa alle emoji

rendi mobile la tastiera virtuale

passa alla scrittura a mano libera

apri impostazioni metodo di immissione

Pagina delle impostazioni tastiera francese BÉPO (lingua francese)

Pagina Impostazioni tastiera Francese

Attiva modalità Fuzzy pinyin

Pagina Impostazioni tastiera Dvorak britannica

Pagina Impostazioni tastiera britannica (inglese)

Pagina Impostazioni tastiera Georgiano

passa alla tastiera precedente

OK

Pagina Impostazioni tastiera Greco

Indietro

Spiacenti, non puoi utilizzare la scrittura a mano libera perché la rete non è disponibile.

Il testo inserito verrà inviato ai server di Google per il riconoscimento.

nascondi tastiera

Pagina Impostazioni tastiera Croato

Pagina Impostazioni tastiera Ungherese

Pagina Impostazioni tastiera Qwerty ungherese

Pagina Impostazioni tastiera Irlandese

Ignora correzione di:

Ignora correzione

Pagina Impostazioni tastiera Ebraico

La lingua di inserimento iniziale è il cinese

La larghezza della punteggiatura iniziale è piena

La larghezza iniziale dei caratteri è piena

Modalità hangul

Modalità hanja

Metodo di immissione Array

Metodo di immissione Cangjie

Cantonese input method

Metodo di immissione Dayi

Metodo di immissione coreano

Metodo di immissione Pinyin

Metodo di immissione rapido

Metodo di immissione Pinyin per cinese tradizionale

Metodo di immissione Wubi

Metodo di immissione Zhuyin

Pagina Impostazioni tastiera Islandese

Pagina Impostazioni tastiera Italiano

Pagina Impostazioni tastiera Giapponese

Tastiera Arabo

Tastiera fonetica Armeno

Tastiera Bielorusso

Tastiera Belga

Tastiera Bengalese (fonetica)

Tastiera Brasiliano

Tastiera Bulgaro

Tastiera fonetica Bulgaro

Tastiera Inglese canadese

Tastiera Francese canadese

Tastiera multilingue Canadese

Tastiera Catalano

Tastiera Croato

Tastiera Ceco

Tastiera QWERTY Ceco

Tastiera Danese

Tastiera Devanagari (fonetica)

Tastiera Estone

Tastiera Etiope

Tastiera Faroese

Tastiera Finlandese

Tastiera Francese

Tastiera francese BÉPO

Tastiera Georgiano

Tastiera Tedesco

Tastiera Neo 2 Tedesco

Tastiera Greco

Tastiera Gujarati (fonetica)

Tastiera Ebraico

Tastiera Ungherese

Tastiera Qwerty ungherese

Tastiera Islandese

Tastiera (InScript)

Tastiera Irlandese

Tastiera Italiano

Tastiera (itrans)

Tastiera Giapponese

Tastiera Kannada (fonetica)

Kazakh keyboard

Tastiera (Kedmanee)

Tastiera Khmer

Tastiera Lao

Tastiera Laotiano

Tastiera Latinoamericano

Tastiera Lettone

Tastiera Lituano

Tastiera Macedone

Tastiera Malayalam (fonetica)

Tastiera Maltese

Tastiera Mongolo

Tastiera Myanmar MM3

Tastiera Myanmar myansan

Tastiera Nepalese (InScript)

Tastiera Nepalese (fonetica)

Tastiera Paesi Bassi

Tastiera

Tastiera Norvegese

Tastiera (Pattachote)

Tastiera Persiano

Tastiera (fonetica)

Tastiera Polacco

Tastiera Portoghese

Tastiera Rumeno

Tastiera Rumeno standard

Tastiera Russo

Tastiera fonetica Russo

Tastiera fonetica Russo (AATSEEL)

Tastiera fonetica Russo (YaZHert)

Tastiera Serbo

Tastiera Singalese

Tastiera Slovacco

Tastiera Slovacco

Tastiera Sloveno

Tastiera basata su arabo curdo

Tastiera basata su inglese curdo

Tastiera Spagnolo

Tastiera Svedese

Tastiera Svizzero

Tastiera Francese svizzero

Tastiera (Tamil99)

Tastiera Tamil (InScript)

Tastiera Tamil (itrans)

Tastiera Tamil (fonetica)

Tastiera Tamil (Tamil99)

Tastiera Tamil (macchina da scrivere)

Tastiera (TCVN)

Tastiera (Telex)

Tastiera Telugu (fonetica)

Tastiera Thailandese (Kedmanee)

Tastiera Thailandese (Pattachote)

Tastiera Thailandese (TIS 820-2531)

Tastiera (TIS 820-2531)

Tastiera Turco

Tastiera Turco F

Tastiera (macchina da scrivere)

Tastiera britannica

Tastiera Dvorak britannica

Tastiera Ucraino

Tastiera USA

Tastiera Colemak USA

Tastiera Dvorak USA

Tastiera US Programmer Dvorak

Tastiera estesa USA

Tastiera internazionale USA

Tastiera Vietnamita (TCVN)

Tastiera Vietnamita (Telex)

Tastiera Vietnamita (VIQR)

Tastiera Vietnamita (VNI)

Tastiera (VIQR)

Tastiera (VNI)

Modalità candidati hanja

Layout tastiera Coreano

Pagina Impostazioni del metodo di immissione coreano

Inserisci una sillaba per volta

Pagina Impostazioni tastiera Latinoamericano (spagnolo)

Impostazioni

freccia sinistra

Pagina Impostazioni tastiera Lituano

Pagina Impostazioni tastiera Lettone (lettone)

apri menu della tastiera

Pagina Impostazioni tastiera Mongolo

Utilizza i tasti - e = per il paging di un elenco di candidati

Utilizza i tasti , e . per il paging di un elenco di candidati

Off

Pagina Impostazioni tastiera Norvegese

Pausa

Correzione automatica

Maiuscole automatiche

Tastiera fisica

Pagina di impostazioni Pinyin

Pagina Impostazioni tastiera Polacco

Pagina Impostazioni tastiera Portoghese

freccia destra

Pagina Impostazioni tastiera Rumeno

Pagina Impostazioni tastiera Serbo

Pagina Impostazioni tastiera fonetica Russo

Pagina Impostazioni tastiera Russo

Pagina Impostazioni tastiera Svedese

Impostazioni

maiusc

Bloc maiusc

Ritardo del menu a discesa di suggerimenti

Mostra menu a discesa di suggerimenti dopo 1 s

Mostra menu a discesa di suggerimenti dopo 2 s

Mostra menu a discesa di suggerimenti dopo 500 ms

Mostra menu a discesa di suggerimenti dopo 5 s

Mostra menu a discesa di suggerimenti tramite Backspace

Mostra candidati in modalità hangul

comprimi elenco candidati

Pagina Impostazioni tastiera Sloveno

Pagina Impostazioni tastiera Slovacco

smiley

Moderata

Suono tasti

spazio

Scorri verso sinistra per eliminare parole intere.

Scorri verso destra per ripristinare parole.

Scorri verso sinistra o destra per spostare il puntatore.

passa a

Passa a layout compatto

Passa a layout completo

passa a

passato a

tab

Tastiera sullo schermo

Pagina Impostazioni tastiera Turco F

Pagina Impostazioni tastiera Turco

Traslitterazione (salam → ሰላም)

Traslitterazione (marhaban ← مرحبا)

Traslitterazione (pryvitannie → прывітанне)

Traslitterazione (zdrasti → здрасти)

Traslitterazione (namaskar → নমস্কার)

Traslitterazione (geia → γεια)

Traslitterazione (salam ← سلام)

Traslitterazione (namaste → નમસ્તે)

Traslitterazione (shalom ← שלום)

Traslitterazione (namaste → नमस्ते)

Traslitterazione (namaskaram → ನಮಸ್ಕಾರ)

Traslitterazione (namaskar → നമസ്കാരം)

Traslitterazione (namaste → नमस्कार)

Traslitterazione (namaste → नमस्ते)

Traslitterazione (mausam → ନମସ୍ତେ)

Traslitterazione (mausam → ਮੌਸਮ)

Traslitterazione (privet → привет)

Traslitterazione (namaste → नमस्ते)

Traslitterazione (halo → හලෝ)

Traslitterazione (zdravo → здраво)

Traslitterazione (vanakkam → வணக்கம்)

Traslitterazione (emandi → ఏమండీ)

Traslitterazione (selam → ሰላም)

Traslitterazione (pryvit → привіт)

Traslitterazione (salam ← سلام)

Traslitterazione (chao → chào)

Pagina Impostazioni tastiera Ucraino

freccia su

Pagina Impostazioni tastiera estesa USA (inglese)

Pagina Impostazioni tastiera Colemak USA (inglese)

Pagina Impostazioni tastiera Dvorak USA (inglese)

Pagina Impostazioni tastiera USA (inglese)

Pagina Impostazioni tastiera USA (filippino)

Pagina Impostazioni tastiera USA (indonesiano)

Pagina Impostazioni tastiera internazionale USA (inglese)

Pagina Impostazioni tastiera internazionale USA (olandese)

Pagina Impostazioni tastiera internazionale USA (portoghese brasiliano)

Pagina Impostazioni tastiera USA (malese)

Attiva dizionario personale

Aggiungi

Cancella tutto

Modifica voci dizionario

Gestisci dizionario personale...

Nuova parola

Rimuovi selezionati

Reimposta tutte le voci di dizionario

Salva

Sincronizza dizionario personale

Dizionario personale

Voce

Il tuo input vocale verrà inviato ai server di Google per il riconoscimento del testo.

disattiva strumento di input vocale

attiva strumento di input vocale

Attendi

Keyboard layouts

Tipo di tastiera

Numero di candidati da visualizzare per pagina

Tasti di selezione

Pagina di impostazioni Zhuyin


use crate::*;

// -----------------------------------------------------------------------------

#[tracable_parser]
#[packrat_parser]
pub(crate) fn timecheck_condition(s: Span) -> IResult<Span, TimecheckCondition> {
    let (s, a) = mintypmax_expression(s)?;
    Ok((s, TimecheckCondition { nodes: (a,) }))
}

#[tracable_parser]
#[packrat_parser]
pub(crate) fn controlled_referecne_event(s: Span) -> IResult<Span, ControlledReferenceEvent> {
    let (s, a) = controlled_timing_check_event(s)?;
    Ok((s, ControlledReferenceEvent { nodes: (a,) }))
}

#[tracable_parser]
#[packrat_parser]
pub(crate) fn data_event(s: Span) -> IResult<Span, DataEvent> {
    let (s, a) = timing_check_event(s)?;
    Ok((s, DataEvent { nodes: (a,) }))
}

#[tracable_parser]
#[packrat_parser]
pub(crate) fn delayed_data(s: Span) -> IResult<Span, DelayedData> {
    alt((
        delayed_data_with_mintypmax,
        map(terminal_identifier, |x| {
            DelayedData::TerminalIdentifier(Box::new(x))
        }),
    ))(s)
}

#[tracable_parser]
#[packrat_parser]
pub(crate) fn delayed_data_with_mintypmax(s: Span) -> IResult<Span, DelayedData> {
    let (s, a) = terminal_identifier(s)?;
    let (s, b) = bracket(constant_mintypmax_expression)(s)?;
    Ok((
        s,
        DelayedData::WithMintypmax(Box::new(DelayedDataWithMintypmax { nodes: (a, b) })),
    ))
}

#[tracable_parser]
#[packrat_parser]
pub(crate) fn delayed_reference(s: Span) -> IResult<Span, DelayedReference> {
    alt((
        delayed_reference_with_mintypmax,
        map(terminal_identifier, |x| {
            DelayedReference::TerminalIdentifier(Box::new(x))
        }),
    ))(s)
}

#[tracable_parser]
#[packrat_parser]
pub(crate) fn delayed_reference_with_mintypmax(s: Span) -> IResult<Span, DelayedReference> {
    let (s, a) = terminal_identifier(s)?;
    let (s, b) = bracket(constant_mintypmax_expression)(s)?;
    Ok((
        s,
        DelayedReference::WithMintypmax(Box::new(DelayedReferenceWithMintypmax { nodes: (a, b) })),
    ))
}

#[tracable_parser]
#[packrat_parser]
pub(crate) fn end_edge_offset(s: Span) -> IResult<Span, EndEdgeOffset> {
    let (s, a) = mintypmax_expression(s)?;
    Ok((s, EndEdgeOffset { nodes: (a,) }))
}

#[tracable_parser]
#[packrat_parser]
pub(crate) fn event_based_flag(s: Span) -> IResult<Span, EventBasedFlag> {
    let (s, a) = constant_expression(s)?;
    Ok((s, EventBasedFlag { nodes: (a,) }))
}

#[tracable_parser]
#[packrat_parser]
pub(crate) fn notifier(s: Span) -> IResult<Span, Notifier> {
    let (s, a) = variable_identifier(s)?;
    Ok((s, Notifier { nodes: (a,) }))
}

#[tracable_parser]
#[packrat_parser]
pub(crate) fn referecne_event(s: Span) -> IResult<Span, ReferenceEvent> {
    let (s, a) = timing_check_event(s)?;
    Ok((s, ReferenceEvent { nodes: (a,) }))
}

#[tracable_parser]
#[packrat_parser]
pub(crate) fn remain_active_flag(s: Span) -> IResult<Span, RemainActiveFlag> {
    let (s, a) = constant_mintypmax_expression(s)?;
    Ok((s, RemainActiveFlag { nodes: (a,) }))
}

#[tracable_parser]
#[packrat_parser]
pub(crate) fn timestamp_condition(s: Span) -> IResult<Span, TimestampCondition> {
    let (s, a) = mintypmax_expression(s)?;
    Ok((s, TimestampCondition { nodes: (a,) }))
}

#[tracable_parser]
#[packrat_parser]
pub(crate) fn start_edge_offset(s: Span) -> IResult<Span, StartEdgeOffset> {
    let (s, a) = mintypmax_expression(s)?;
    Ok((s, StartEdgeOffset { nodes: (a,) }))
}

#[tracable_parser]
#[packrat_parser]
pub(crate) fn threshold(s: Span) -> IResult<Span, Threshold> {
    let (s, a) = constant_expression(s)?;
    Ok((s, Threshold { nodes: (a,) }))
}

#[tracable_parser]
#[packrat_parser]
pub(crate) fn timing_check_limit(s: Span) -> IResult<Span, TimingCheckLimit> {
    let (s, a) = expression(s)?;
    Ok((s, TimingCheckLimit { nodes: (a,) }))
}


#!/bin/bash

DIR="@abs_top_srcdir@"
BDIR="@abs_top_builddir@"
LOG="/tmp/zbar_dbus_test_$$.log"
LOG_BIN="/tmp/zbar_dbus_test_$$.bin"

EXPECTED="7294377b69fb00c7e0811429ab7a42cc8cecfda0"
EXPECTED_BIN="df896e459e47a7d392031a7d4962722a143e276b"

$BDIR/test/test_dbus -c2 -t5 --log=$LOG --bin-log=$LOG_BIN &
PID=$!

trap "rm -r $LOG $LOG_BIN" EXIT

$BDIR/zbarimg/zbarimg $DIR/examples/code-128.png 2>/dev/null >/dev/null
$BDIR/zbarimg/zbarimg -Sbinary $DIR/examples/qr-code-binary.png 2>/dev/null >/dev/null

wait $PID

if [ ! -s $LOG ] || [ ! -s $LOG_BIN ]; then
	echo "FAILED: nothing received via D-Bus"
    exit -2
fi

CK="`cat $LOG  |sha1sum |cut -d" " -f 1`"
if [ "x$CK" != "x$EXPECTED" ]; then
    echo "FAILED: $CK instead of $EXPECTED"
    exit -2
fi

CK_BIN="`cat $LOG_BIN  |sha1sum |cut -d" " -f 1`"
if [ "x$CK_BIN" != "x$EXPECTED_BIN" ]; then
    echo "FAILED: $CK_BIN instead of $EXPECTED_BIN"
    exit -2
fi

echo "D-Bus PASSED."


<?xml version="1.0"?>
<!--
/*******************************************************************************
 * Copyright (c) 2000-present Liferay, Inc. All rights reserved.
 *
 * This library is free software; you can redistribute it and/or modify it under
 * the terms of the GNU Lesser General Public License as published by the Free
 * Software Foundation; either version 2.1 of the License, or (at your option)
 * any later version.
 *
 * This library is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
 * details.
 *
 *******************************************************************************/
-->
<project
	xmlns="http://maven.apache.org/POM/4.0.0"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd"
>
	<modelVersion>4.0.0</modelVersion>

	<parent>
		<groupId>com.liferay.ide.functional.base</groupId>
		<artifactId>base-tests</artifactId>
		<version>3.9.0-SNAPSHOT</version>
	</parent>

	<artifactId>com.liferay.ide.functional.kaleo.deploy.base</artifactId>
	<packaging>eclipse-plugin</packaging>

	<name>Liferay IDE Functional Kaleo Deploy Base</name>
</project>


`import Fieldset from 'box-ui-elements/es/components/fieldset;`


<?php

namespace Concrete\Tests\Routing;

use Config;
use Core;
use Monolog\Logger;
use Page;
use Concrete\Tests\TestCase;
use URL;

class URLTest extends TestCase
{
    /**
     * Here's the expected behavior.
     * All URLs generated should have index.php in front of them if
     * concrete.seo.url_rewriting is false.
     * If concrete.seo.url_rewriting is true, then all URLs should have
     * no index.php, unless they're in the Dashboard.
     * If concrete.seo.url_rewriting_all is true, then all URLs (including Dashboard)
     * should be free of index.php.
     *
     * This should be the case whether something is being called via URL::to, URL::page,
     * or Page::getCollectionLink or \Concrete\Core\Html\Service\Navigation::getLinkToCollection
     */
    public function setUp()
    {
        $locale = new \Concrete\Core\Entity\Site\Locale();
        $locale->setCountry('US');
        $locale->setLanguage('en');
        $siteTree = new \Concrete\Core\Entity\Site\SiteTree();
        $siteTree->setLocale($locale);
        $service = Core::make('helper/navigation');
        $page = new Page();
        $page->siteTree = $siteTree;
        $page->cPath = '/path/to/my/page';
        $page->error = false;
        $dashboard = new Page();
        $dashboard->cPath = '/dashboard/my/awesome/page';
        $dashboard->error = false;
        $this->page = $page;
        $this->dashboard = $dashboard;
        $page->siteTree = $siteTree;
        $dashboard->siteTree = $siteTree;
        $this->service = $service;

        $app = \Concrete\Core\Support\Facade\Facade::getFacadeApplication();
        $app->bind('\Psr\Log\LoggerInterface', function () {
            return new \Psr\Log\NullLogger();
        });
        Config::set('concrete.seo.url_rewriting', false);
        Config::set('concrete.seo.url_rewriting_all', false);
        $siteConfig = Core::make('site')->getSite()->getConfigRepository();
        $this->oldUrl = $siteConfig->get('seo.canonical_url');
        $siteConfig->set('seo.canonical_url', 'http://dummyurl.com');

        parent::setUp();
    }

    public function tearDown()
    {
        Core::make('site')->getSite()->getConfigRepository()->set('seo.canonical_url', $this->oldUrl);
        $this->clearCanonicalUrl();

        $app = \Concrete\Core\Support\Facade\Facade::getFacadeApplication();
        $app->bind('Psr\Log\LoggerInterface', 'log/application');

        parent::tearDown();
    }

    public function testPathToSiteInApplication()
    {
        $this->assertEquals('/path/to/server', \Core::getApplicationRelativePath());
    }

    public function testNoUrlRewriting()
    {
        $this->assertEquals('http://dummyurl.com/path/to/server/index.php/path/to/my/page', (string) $this->page->getCollectionLink());
        $this->assertEquals('http://dummyurl.com/path/to/server/index.php/path/to/my/page',
                            (string) $this->service->getLinkToCollection($this->page)
        );
        $this->assertEquals('http://dummyurl.com/path/to/server/index.php/path/to/my/page', (string) URL::to('/path/to/my/page'));
        $this->assertEquals('http://dummyurl.com/path/to/server/index.php/path/to/my/page', (string) URL::page($this->page));
    }

    public function testNoUrlRewritingNoRelativePath()
    {
        $app = Core::make('app');
        $app['app_relative_path'] = '';
        $app->instance('app', $app);

        $app->make('Concrete\Core\Url\Resolver\CanonicalUrlResolver')->clearCached();

        $this->assertEquals('http://dummyurl.com/index.php/path/to/my/page', (string) $this->page->getCollectionLink());
        $this->assertEquals('http://dummyurl.com/index.php/path/to/my/page',
                            (string) $this->service->getLinkToCollection($this->page)
        );
        $this->assertEquals('http://dummyurl.com/index.php/path/to/my/page', (string) URL::to('/path/to/my/page'));
        $this->assertEquals('http://dummyurl.com/index.php/path/to/my/page', (string) URL::page($this->page));
    }

    public function testUrlRewriting()
    {
        $app = Core::make('app');
        $app['app_relative_path'] = '/path/to/server';
        $app->instance('app', $app);

        Config::set('concrete.seo.url_rewriting', true);
        $this->assertEquals('http://dummyurl.com/path/to/server/path/to/my/page', (string) $this->page->getCollectionLink());
        $this->assertEquals('http://dummyurl.com/path/to/server/path/to/my/page',
                            (string) $this->service->getLinkToCollection($this->page)
        );
        $this->assertEquals('http://dummyurl.com/path/to/server/path/to/my/page', (string) URL::to('/path/to/my/page'));
        $this->assertEquals('http://dummyurl.com/path/to/server/path/to/my/page', (string) URL::page($this->page));
    }

    public function testCanonicalURLRedirection()
    {
        $app = Core::make('app');
        $config = Core::make('config');
        $original_redirect_to_canonical_url = $config->get('concrete.seo.redirect_to_canonical_url');
        $original_trailing_slash = $config->get('concrete.seo.trailing_slash');
        try {
            $config->set('concrete.seo.redirect_to_canonical_url', true);
            $config->set('concrete.seo.trailing_slash', false);
            $request = \Concrete\Core\Http\Request::create('http://www.awesome.com/path/to/site/index.php/dashboard?bar=1&foo=1');

            $site = $this->getMockBuilder(\Concrete\Core\Entity\Site\Site::class)
                ->disableOriginalConstructor()
                ->getMock();

            $liaison = $this->getMockBuilder(\Concrete\Core\Config\Repository\Liaison::class)
                ->disableOriginalConstructor()
                ->getMock();

            $liaison->expects($this->any())
                ->method('get')
                ->will($this->returnValueMap([
                    ['seo.canonical_url', null, 'https://www2.myawesomesite.com:8080'],
                    ['seo.canonical_url_alternative', null, 'https://www2.myawesomesite.com:8080'],
                ]));

            $site->expects($this->once())
                ->method('getConfigRepository')
                ->will($this->returnValue($liaison));

            $response = $app->handleCanonicalURLRedirection($request, $site);

            $this->assertEquals('https://www2.myawesomesite.com:8080/path/to/site/index.php/dashboard?bar=1&foo=1', $response->getTargetUrl());
        } finally {
            $config->set('concrete.seo.redirect_to_canonical_url', $original_redirect_to_canonical_url);
            $config->set('concrete.seo.trailing_slash', $original_trailing_slash);
        }
    }

    public function testCanonicalURLRedirectionSameDomain()
    {
        $app = Core::make('app');

        $site = $this->getMockBuilder(\Concrete\Core\Entity\Site\Site::class)
            ->disableOriginalConstructor()
            ->getMock();

        $liaison = $this->getMockBuilder(\Concrete\Core\Config\Repository\Liaison::class)
            ->disableOriginalConstructor()
            ->getMock();

        $liaison->expects($this->any())
            ->method('get')
            ->will($this->returnValueMap([
                ['seo.canonical_url', null, 'http://concrete5.dev'],
            ]));

        $site->expects($this->any())
            ->method('getConfigRepository')
            ->will($this->returnValue($liaison));

        Config::set('concrete.seo.redirect_to_canonical_url', true);
        $request = \Concrete\Core\Http\Request::create('http://concrete5.dev/login');
        $response = $app->handleCanonicalURLRedirection($request, $site);
        $this->assertNull($response);

        $request = \Concrete\Core\Http\Request::create('http://concrete5.dev/index.php?cID=1');
        $response = $app->handleCanonicalURLRedirection($request, $site);
        $this->assertNull($response);
    }

    public function testCanonicalUrlRedirectionSslUrl()
    {
        $app = Core::make('app');

        $site = $this->getMockBuilder(\Concrete\Core\Entity\Site\Site::class)
            ->disableOriginalConstructor()
            ->getMock();

        $liaison = $this->getMockBuilder(\Concrete\Core\Config\Repository\Liaison::class)
            ->disableOriginalConstructor()
            ->getMock();

        $liaison->expects($this->any())
            ->method('get')
            ->will($this->returnValueMap([
                ['seo.canonical_url', null, 'http://mysite.com'],
                ['seo.canonical_url_alternative', null, 'https://secure.mysite.com:8080'],
            ]));

        $site->expects($this->once())
            ->method('getConfigRepository')
            ->will($this->returnValue($liaison));

        Config::set('concrete.seo.redirect_to_canonical_url', true);

        $request = \Concrete\Core\Http\Request::create('https://secure.mysite.com:8080/path/to/page');
        $response = $app->handleCanonicalURLRedirection($request, $site);
        $this->assertNull($response);
        Config::set('concrete.seo.redirect_to_canonical_url', false);
    }

    public function testPathSlashesRedirection()
    {
        $app = Core::make('app');
        $config = Core::make('config');

        $original_trailing_slash = $config->get('concrete.seo.trailing_slash');
        $site = $this->getMockBuilder(\Concrete\Core\Entity\Site\Site::class)
            ->disableOriginalConstructor()
            ->getMock();
        try {
            $config->set('concrete.seo.trailing_slash', false);

            $request = \Concrete\Core\Http\Request::create('http://xn--mgbh0fb.xn--kgbechtv/services');
            $response = $app->handleURLSlashes($request, $site);
            $this->assertNull($response);

            $request = \Concrete\Core\Http\Request::create('http://xn--fsqu00a.xn--0zwm56d/services/');
            $response = $app->handleURLSlashes($request, $site);
            $this->assertEquals('http://例子.测试/services', $response->getTargetUrl());

            $request = \Concrete\Core\Http\Request::create('http://concrete5.dev/derp');
            $response = $app->handleURLSlashes($request, $site);
            $this->assertNull($response);

            $request = \Concrete\Core\Http\Request::create('http://concrete5.dev/index.php?cID=1');
            $response = $app->handleURLSlashes($request, $site);
            $this->assertNull($response);

            $request = \Concrete\Core\Http\Request::create('http://www.awesome.com/about-us/now');
            $response = $app->handleURLSlashes($request, $site);
            $this->assertNull($response);

            $request = \Concrete\Core\Http\Request::create('http://www.awesome.com/about-us/now/');
            $response = $app->handleURLSlashes($request, $site);
            $this->assertInstanceOf('\Concrete\Core\Routing\RedirectResponse', $response);
            $this->assertEquals('http://www.awesome.com/about-us/now', $response->getTargetUrl());

            $request = \Concrete\Core\Http\Request::create('http://www.awesome.com/index.php/about-us/now/?bar=1&foo=2');
            $response = $app->handleURLSlashes($request, $site);
            $this->assertInstanceOf('\Concrete\Core\Routing\RedirectResponse', $response);
            $this->assertEquals('http://www.awesome.com/index.php/about-us/now?bar=1&foo=2', $response->getTargetUrl());

            $config->set('concrete.seo.trailing_slash', true);

            $request = \Concrete\Core\Http\Request::create('http://www.awesome.com:8080/index.php/about-us/now/?bar=1&foo=2');
            $response = $app->handleURLSlashes($request, $site);
            $this->assertNull($response);

            $request = \Concrete\Core\Http\Request::create('http://www.awesome.com:8080/index.php/about-us/now?bar=1&foo=2');
            $response = $app->handleURLSlashes($request, $site);
            $this->assertEquals('http://www.awesome.com:8080/index.php/about-us/now/?bar=1&foo=2', $response->getTargetUrl());
        } finally {
            $config->set('concrete.seo.trailing_slash', $original_trailing_slash);
        }
    }

    public function testUrlRewritingAll()
    {
        Config::set('concrete.seo.url_rewriting', true);
        Config::set('concrete.seo.url_rewriting_all', true);
        $this->assertEquals('http://dummyurl.com/path/to/server/path/to/my/page', (string) $this->page->getCollectionLink());
        $this->assertEquals('http://dummyurl.com/path/to/server/path/to/my/page',
                            (string) $this->service->getLinkToCollection($this->page)
        );
        $this->assertEquals('http://dummyurl.com/path/to/server/path/to/my/page', URL::to('/path/to/my/page'));
        $this->assertEquals('http://dummyurl.com/path/to/server/path/to/my/page', URL::page($this->page));
    }

    public function testNoUrlRewritingDashboard()
    {
        $app = Core::make('app');
        $app['app_relative_path'] = '/path/to/server';
        $this->assertEquals('http://dummyurl.com/path/to/server/index.php/dashboard/my/awesome/page', (string) $this->dashboard->getCollectionLink());
        $this->assertEquals('http://dummyurl.com/path/to/server/index.php/dashboard/my/awesome/page',
                            (string) $this->service->getLinkToCollection($this->dashboard)
        );
        $this->assertEquals('http://dummyurl.com/path/to/server/index.php/dashboard/my/awesome/page', (string) URL::to('/dashboard/my/awesome/page'));
        $this->assertEquals('http://dummyurl.com/path/to/server/index.php/dashboard/my/awesome/page', (string) URL::page($this->dashboard));
    }

    public function testPagesWithNoPaths()
    {
        $locale = new \Concrete\Core\Entity\Site\Locale();
        $locale->setCountry('US');
        $locale->setLanguage('en');
        $siteTree = new \Concrete\Core\Entity\Site\SiteTree();
        $siteTree->setLocale($locale);

        $home = new Page();
        $home->cID = 1;
        $home->cPath = '';
        $home->siteTree = $siteTree;

        $url = \URL::to($home);
        $this->assertEquals('http://dummyurl.com/path/to/server/index.php?cID=' . $home->cID, (string) $url);

        $url = \URL::to('/');
        $this->assertEquals('http://dummyurl.com/path/to/server/index.php', (string) $url);

        $page = new Page();
        $page->cPath = null;
        $page->cID = 777;
        $page->siteTree = $siteTree;

        $url = \URL::to($page);
        $this->assertEquals('http://dummyurl.com/path/to/server/index.php?cID=777', (string) $url);
    }

    public function testUrlRewritingDashboard()
    {
        Config::set('concrete.seo.url_rewriting', true);
        $this->assertEquals('http://dummyurl.com/path/to/server/index.php/dashboard/my/awesome/page', (string) $this->dashboard->getCollectionLink());
        $this->assertEquals('http://dummyurl.com/path/to/server/index.php/dashboard/my/awesome/page',
                            (string) $this->service->getLinkToCollection($this->dashboard)
        );
        $this->assertEquals('http://dummyurl.com/path/to/server/index.php/dashboard/my/awesome/page', (string) URL::to('/dashboard/my/awesome/page'));
        $this->assertEquals('http://dummyurl.com/path/to/server/index.php/dashboard/my/awesome/page', (string) URL::page($this->dashboard));
    }

    public function testUrlRewritingAllDashboard()
    {
        Config::set('concrete.seo.url_rewriting', true);
        Config::set('concrete.seo.url_rewriting_all', true);
        $this->assertEquals('http://dummyurl.com/path/to/server/dashboard/my/awesome/page', (string) $this->dashboard->getCollectionLink());
        $this->assertEquals('http://dummyurl.com/path/to/server/dashboard/my/awesome/page',
                            (string) $this->service->getLinkToCollection($this->dashboard)
        );
        $this->assertEquals('http://dummyurl.com/path/to/server/dashboard/my/awesome/page', (string) URL::to('/dashboard/my/awesome/page'));
        $this->assertEquals('http://dummyurl.com/path/to/server/dashboard/my/awesome/page', (string) URL::page($this->dashboard));
    }

    public function testCanonicalUrl()
    {
        Core::make('site')->getSite()->getConfigRepository()->set('seo.canonical_url', 'http://www.derpco.com');
        $this->clearCanonicalUrl();

        $this->assertEquals('http://www.derpco.com/path/to/server/index.php/dashboard/my/awesome/page', (string) URL::to('/dashboard/my/awesome/page'));
        $this->assertEquals('http://www.derpco.com/path/to/server/index.php/dashboard/my/awesome/page', (string) URL::page($this->dashboard));
    }

    public function testCanonicalUrlWithPort()
    {
        Core::make('site')->getSite()->getConfigRepository()->set('seo.canonical_url', 'http://www.derpco.com:8080');
        $this->clearCanonicalUrl();
        $this->assertEquals('http://www.derpco.com:8080/path/to/server/index.php/dashboard/my/awesome/page', (string) URL::to('/dashboard/my/awesome/page'));
        $this->assertEquals('http://www.derpco.com:8080/path/to/server/index.php/dashboard/my/awesome/page', (string) URL::page($this->dashboard));
    }

    public function testURLFunctionWithCanonicalURL()
    {
        Core::make('site')->getSite()->getConfigRepository()->set('seo.canonical_url', 'http://concrete5');

        $this->clearCanonicalUrl();

        $url = URL::to('/dashboard/system/test', 'outstanding');
        $this->assertEquals('http://concrete5/path/to/server/index.php/dashboard/system/test/outstanding', (string) $url);
    }

    public function testURLFunctionWithoutCanonicalURL()
    {
        Core::make('site')->getSite()->getConfigRepository()->set('seo.canonical_url', '');

        $this->clearCanonicalUrl();

        $url = URL::to('/dashboard/system/test', 'outstanding');
        // www.requestdomain.com is set by the bootstrap.php file
        $this->assertEquals('http://www.requestdomain.com/path/to/server/index.php/dashboard/system/test/outstanding', (string) $url);
    }

    private function clearCanonicalUrl()
    {
        $app = \Concrete\Core\Support\Facade\Application::getFacadeApplication();
        $app->make('Concrete\Core\Url\Resolver\CanonicalUrlResolver')->clearCached();
    }
}


package org.eclipse.ceylon.compiler.java.test.statement.loop;

class MethodWhileIsNotObject implements .org.eclipse.ceylon.compiler.java.runtime.model.ReifiedType, .java.io.Serializable {

    MethodWhileIsNotObject() {
    }

    public final void m(final .java.lang.Object x) {
        loop_0: while (true) {
            if (!(x != null)) {
                .ceylon.language.print_.print(.ceylon.language.String.instance("x is null"));
                .ceylon.language.print_.print(x);
            } else {
                break loop_0;
            }
        }
    }

    public final void mvar(final .java.lang.Object y) {
        loop_1: while (true) {
            .java.lang.Object x$1;
            if (!((x$1 = y) != null)) {
                final .java.lang.Object x$2 = x$1;
                .ceylon.language.print_.print(.ceylon.language.String.instance("x is null"));
                .ceylon.language.print_.print(x$2);
            } else {
                break loop_1;
            }
        }
    }

    @.java.lang.Override
    public .org.eclipse.ceylon.compiler.java.runtime.model.TypeDescriptor $getType$() {
        return .org.eclipse.ceylon.compiler.java.test.statement.loop.MethodWhileIsNotObject.$TypeDescriptor$;
    }
    public static final .org.eclipse.ceylon.compiler.java.runtime.model.TypeDescriptor $TypeDescriptor$ = .org.eclipse.ceylon.compiler.java.runtime.model.TypeDescriptor.klass(.org.eclipse.ceylon.compiler.java.test.statement.loop.MethodWhileIsNotObject.class);
}