text:
// Copyright 2018 Google LLC
//
// 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.

package com.google.location.suplclient.asn1.supl2.ulp_version_2_message_extensions;

// Copyright 2008 Google Inc. All Rights Reserved.
/*
 * This class is AUTOMATICALLY GENERATED. Do NOT EDIT.
 */

//
//
import com.google.location.suplclient.asn1.base.Asn1Integer;
import com.google.location.suplclient.asn1.base.Asn1Object;
import com.google.location.suplclient.asn1.base.Asn1Sequence;
import com.google.location.suplclient.asn1.base.Asn1Tag;
import com.google.location.suplclient.asn1.base.BitStream;
import com.google.location.suplclient.asn1.base.BitStreamReader;
import com.google.location.suplclient.asn1.base.SequenceComponent;
import com.google.common.collect.ImmutableList;
import java.util.Collection;
import javax.annotation.Nullable;

/**
*
*/
public  class ReportingCriteria extends Asn1Sequence {
  //

  private static final Asn1Tag TAG_ReportingCriteria
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public ReportingCriteria() {
    super();
  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_ReportingCriteria;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_ReportingCriteria != null) {
      return ImmutableList.of(TAG_ReportingCriteria);
    } else {
      return Asn1Sequence.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new ReportingCriteria from encoded stream.
   */
  public static ReportingCriteria fromPerUnaligned(byte[] encodedBytes) {
    ReportingCriteria result = new ReportingCriteria();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new ReportingCriteria from encoded stream.
   */
  public static ReportingCriteria fromPerAligned(byte[] encodedBytes) {
    ReportingCriteria result = new ReportingCriteria();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override protected boolean isExtensible() {
    return true;
  }

  @Override public boolean containsExtensionValues() {
    for (SequenceComponent extensionComponent : getExtensionComponents()) {
      if (extensionComponent.isExplicitlySet()) return true;
    }
    return false;
  }

  private TimeWindow timeWindow_;
  public TimeWindow getTimeWindow() {
    return timeWindow_;
  }
  /**
   * @throws ClassCastException if value is not a TimeWindow
   */
  public void setTimeWindow(Asn1Object value) {
    this.timeWindow_ = (TimeWindow) value;
  }
  public TimeWindow setTimeWindowToNewInstance() {
    timeWindow_ = new TimeWindow();
    return timeWindow_;
  }

  private ReportingCriteria.maxNumberofReportsType maxNumberofReports_;
  public ReportingCriteria.maxNumberofReportsType getMaxNumberofReports() {
    return maxNumberofReports_;
  }
  /**
   * @throws ClassCastException if value is not a ReportingCriteria.maxNumberofReportsType
   */
  public void setMaxNumberofReports(Asn1Object value) {
    this.maxNumberofReports_ = (ReportingCriteria.maxNumberofReportsType) value;
  }
  public ReportingCriteria.maxNumberofReportsType setMaxNumberofReportsToNewInstance() {
    maxNumberofReports_ = new ReportingCriteria.maxNumberofReportsType();
    return maxNumberofReports_;
  }

  private ReportingCriteria.minTimeIntervalType minTimeInterval_;
  public ReportingCriteria.minTimeIntervalType getMinTimeInterval() {
    return minTimeInterval_;
  }
  /**
   * @throws ClassCastException if value is not a ReportingCriteria.minTimeIntervalType
   */
  public void setMinTimeInterval(Asn1Object value) {
    this.minTimeInterval_ = (ReportingCriteria.minTimeIntervalType) value;
  }
  public ReportingCriteria.minTimeIntervalType setMinTimeIntervalToNewInstance() {
    minTimeInterval_ = new ReportingCriteria.minTimeIntervalType();
    return minTimeInterval_;
  }

  @Override public Iterable<? extends SequenceComponent> getComponents() {
    ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();

    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 0);

          @Override public boolean isExplicitlySet() {
            return getTimeWindow() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

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

          @Override public Asn1Object getComponentValue() {
            return getTimeWindow();
          }

          @Override public void setToNewInstance() {
            setTimeWindowToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? TimeWindow.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

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

          @Override public String toIndentedString(String indent) {
                return "timeWindow : "
                    + getTimeWindow().toIndentedString(indent);
              }
        });

    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 1);

          @Override public boolean isExplicitlySet() {
            return getMaxNumberofReports() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

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

          @Override public Asn1Object getComponentValue() {
            return getMaxNumberofReports();
          }

          @Override public void setToNewInstance() {
            setMaxNumberofReportsToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? ReportingCriteria.maxNumberofReportsType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

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

          @Override public String toIndentedString(String indent) {
                return "maxNumberofReports : "
                    + getMaxNumberofReports().toIndentedString(indent);
              }
        });

    builder.add(new SequenceComponent() {
          Asn1Tag tag = Asn1Tag.fromClassAndNumber(2, 2);

          @Override public boolean isExplicitlySet() {
            return getMinTimeInterval() != null;
          }

          @Override public boolean hasDefaultValue() {
            return false;
          }

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

          @Override public Asn1Object getComponentValue() {
            return getMinTimeInterval();
          }

          @Override public void setToNewInstance() {
            setMinTimeIntervalToNewInstance();
          }

          @Override public Collection<Asn1Tag> getPossibleFirstTags() {
            return tag == null ? ReportingCriteria.minTimeIntervalType.getPossibleFirstTags() : ImmutableList.of(tag);
          }

          @Override
          public Asn1Tag getTag() {
            return tag;
          }

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

          @Override public String toIndentedString(String indent) {
                return "minTimeInterval : "
                    + getMinTimeInterval().toIndentedString(indent);
              }
        });

    return builder.build();
  }

  @Override public Iterable<? extends SequenceComponent>
                                                    getExtensionComponents() {
    ImmutableList.Builder<SequenceComponent> builder = ImmutableList.builder();

      return builder.build();
    }

  // Copyright 2008 Google Inc. All Rights Reserved.
/*
 * This class is AUTOMATICALLY GENERATED. Do NOT EDIT.
 */

//

/**
 *
 */
public static class maxNumberofReportsType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_maxNumberofReportsType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public maxNumberofReportsType() {
    super();
    setValueRange(new java.math.BigInteger("1"), new java.math.BigInteger("65536"));

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_maxNumberofReportsType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_maxNumberofReportsType != null) {
      return ImmutableList.of(TAG_maxNumberofReportsType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new maxNumberofReportsType from encoded stream.
   */
  public static maxNumberofReportsType fromPerUnaligned(byte[] encodedBytes) {
    maxNumberofReportsType result = new maxNumberofReportsType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new maxNumberofReportsType from encoded stream.
   */
  public static maxNumberofReportsType fromPerAligned(byte[] encodedBytes) {
    maxNumberofReportsType result = new maxNumberofReportsType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "maxNumberofReportsType = " + getInteger() + ";\n";
  }
}

  // Copyright 2008 Google Inc. All Rights Reserved.
/*
 * This class is AUTOMATICALLY GENERATED. Do NOT EDIT.
 */

//

/**
 *
 */
public static class minTimeIntervalType extends Asn1Integer {
  //

  private static final Asn1Tag TAG_minTimeIntervalType
      = Asn1Tag.fromClassAndNumber(-1, -1);

  public minTimeIntervalType() {
    super();
    setValueRange(new java.math.BigInteger("1"), new java.math.BigInteger("86400"));

  }

  @Override
  @Nullable
  protected Asn1Tag getTag() {
    return TAG_minTimeIntervalType;
  }

  @Override
  protected boolean isTagImplicit() {
    return true;
  }

  public static Collection<Asn1Tag> getPossibleFirstTags() {
    if (TAG_minTimeIntervalType != null) {
      return ImmutableList.of(TAG_minTimeIntervalType);
    } else {
      return Asn1Integer.getPossibleFirstTags();
    }
  }

  /**
   * Creates a new minTimeIntervalType from encoded stream.
   */
  public static minTimeIntervalType fromPerUnaligned(byte[] encodedBytes) {
    minTimeIntervalType result = new minTimeIntervalType();
    result.decodePerUnaligned(new BitStreamReader(encodedBytes));
    return result;
  }

  /**
   * Creates a new minTimeIntervalType from encoded stream.
   */
  public static minTimeIntervalType fromPerAligned(byte[] encodedBytes) {
    minTimeIntervalType result = new minTimeIntervalType();
    result.decodePerAligned(new BitStreamReader(encodedBytes));
    return result;
  }

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    return "minTimeIntervalType = " + getInteger() + ";\n";
  }
}

  @Override public Iterable<BitStream> encodePerUnaligned() {
    return super.encodePerUnaligned();
  }

  @Override public Iterable<BitStream> encodePerAligned() {
    return super.encodePerAligned();
  }

  @Override public void decodePerUnaligned(BitStreamReader reader) {
    super.decodePerUnaligned(reader);
  }

  @Override public void decodePerAligned(BitStreamReader reader) {
    super.decodePerAligned(reader);
  }

  @Override public String toString() {
    return toIndentedString("");
  }

  public String toIndentedString(String indent) {
    StringBuilder builder = new StringBuilder();
    builder.append("ReportingCriteria = {\n");
    final String internalIndent = indent + "  ";
    for (SequenceComponent component : getComponents()) {
      if (component.isExplicitlySet()) {
        builder.append(internalIndent)
            .append(component.toIndentedString(internalIndent));
      }
    }
    if (isExtensible()) {
      builder.append(internalIndent).append("...\n");
      for (SequenceComponent component : getExtensionComponents()) {
        if (component.isExplicitlySet()) {
          builder.append(internalIndent)
              .append(component.toIndentedString(internalIndent));
        }
      }
    }
    builder.append(indent).append("};\n");
    return builder.toString();
  }
}


text:
package ru.job4j.shapes;

/**
 * Created on 08.09.2017.
 *
 * Class Paint draws the figure.
 *
 * @author Aleks Sidorenko (alek.sidorenko1979@gmail.com).
 * @version $Id$.
 * @since 0.1.
 */
public class Paint {

    /**
     * @param shape - triangle, square.
     */
    private Shape shape;

    /**
     * Method draws shape.
     *
     * @param shape - triangle, square.
     */
    public void draw(Shape shape) {
        System.out.println(shape.pic());
    }
}

redpajama_set_name: RedPajamaGithub


text:
<!DOCTYPE html>

<meta charset="utf-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title><?php echo config_item('admin_page_title'); ?></title>
<link href="<?php echo config_item('base_url'); ?>assets/css/bootstrap.min.css" rel="stylesheet">
<link href="<?php echo config_item('base_url'); ?>assets/css/font-awesome.css" rel="stylesheet">
<link href="<?php echo config_item('base_url'); ?>assets/css/animate.css" rel="stylesheet">
<link href="<?php echo config_item('base_url'); ?>assets/css/style.css" rel="stylesheet">
<link href="<?php echo config_item('base_url'); ?>assets/css/awesome-bootstrap-checkbox.css" rel="stylesheet">
<link href="<?php echo config_item('base_url'); ?>assets/css/datatables.min.css" rel="stylesheet">
<link href="<?php echo config_item('base_url'); ?>assets/css/datepicker.css" rel="stylesheet">

       <?php $this->load->view('include/inc_navigation'); ?>

	   <?php $this->load->view('include/inc_topnav'); ?>

                <?php $this->load->view('include/inc_sidebar'); ?>

Front End User

											<select class="form-control m-b" id="locality">
										        <option value="">-- Select Locality --</option>
											        <?php
													  if (is_array($location) && count($location) > 0)
  												      foreach ($location as $loc_val)
												      echo "<option value=\"$loc_val->id\">$loc_val->locality</option>";
													?>
											</select>

									          <button type="button" class="btn btn-primary" onclick="filterdata()">Submit</button>

												S No
												User Name
												Locality

												Email Id
												Mobile No.
												Action

										<?php
											   if (count($front) > 0)
												   {
													   $i = 0;
													   foreach ($front as $data)
														   {
															   $i++;

															   echo '

																		'.$i.'

																		'.$data->{'name'}.'

																		'.getUserLocality($data->id).'

																			'.$data->{'email'}.'
																		'.($data->{'contactno'} != '' ? $data->{'contactno'} : '-------------------------').'

																		{'id'}.'">  {'id'}.'" onclick="return confirm(\'Are you sure! You want to Delete this entries ?\')">

';
														   }
												   }
											   else
												   {
															   echo '

																		No Data.

';
												   }
								?>

             <?php $this->load->view('include/inc_footer'); ?>


text:
package org.jbb.security.rest.password;

import org.jbb.lib.test.PojoTest;

public class PasswordPolicyDtoTest extends PojoTest {

    @Override
    public Class getClassUnderTest() {
        return PasswordPolicyDto.class;
    }
}


text:
import Dispatcher from "../Dispatcher/Dispatcher";
import AppLoadedAction from "../Actions/AppLoadedAction";
import SayHelloAction from "../Actions/SayHelloAction";

export function loadApp(): void {
    const bodyTitle: string = "The standard Lorem Ipsum passage, used since the 1500s";
    const bodySummary: string = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor" +
        "incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco" +
        "laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate" +
        "velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt" +
        "in culpa qui officia deserunt mollit anim id est laborum.";

    Dispatcher.dispatch(new AppLoadedAction(bodyTitle, bodySummary));
}

export function sayHello(): void {
        Dispatcher.dispatch(new SayHelloAction());
}


text:
package org.apache.hadoop.mapred;

import java.io.IOException;

import org.apache.hadoop.classification.InterfaceAudience;
import org.apache.hadoop.classification.InterfaceStability;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.io.Text;
import org.apache.hadoop.io.Writable;
import org.apache.hadoop.io.WritableComparable;

/**
 * This class converts the input keys and values to their String forms by calling toString()
 * method. This class to SequenceFileAsTextInputFormat class is as LineRecordReader
 * class to TextInputFormat class.
 */
@InterfaceAudience.Public
@InterfaceStability.Stable
public class SequenceFileAsTextRecordReader
  implements RecordReader<Text, Text> {

  private final SequenceFileRecordReader<WritableComparable, Writable>
  sequenceFileRecordReader;

  private WritableComparable innerKey;
  private Writable innerValue;

  public SequenceFileAsTextRecordReader(Configuration conf, FileSplit split)
    throws IOException {
    sequenceFileRecordReader =
      new SequenceFileRecordReader<WritableComparable, Writable>(conf, split);
    innerKey = sequenceFileRecordReader.createKey();
    innerValue = sequenceFileRecordReader.createValue();
  }

  public Text createKey() {
    return new Text();
  }

  public Text createValue() {
    return new Text();
  }

  /** Read key/value pair in a line. */
  public synchronized boolean next(Text key, Text value) throws IOException {
    Text tKey = key;
    Text tValue = value;
    if (!sequenceFileRecordReader.next(innerKey, innerValue)) {
      return false;
    }
    tKey.set(innerKey.toString());
    tValue.set(innerValue.toString());
    return true;
  }

  public float getProgress() throws IOException {
    return sequenceFileRecordReader.getProgress();
  }

  public synchronized long getPos() throws IOException {
    return sequenceFileRecordReader.getPos();
  }

  public synchronized void close() throws IOException {
    sequenceFileRecordReader.close();
  }

}


text:
"""A setuptools based setup module."""
from os import path

from setuptools import setup

from yala import __version__

HERE = path.abspath(path.dirname(__file__))

# Get the long description from the README file
with open(path.join(HERE, "README.rst"), encoding="ascii") as f:
    LONG_DESC = f.read()

setup(
    name="yala",
    version=__version__,
    description="Yet Another Linter Aggregator",
    long_description=LONG_DESC,
    url="https://github.com/cemsbr/yala",
    author="Carlos Eduardo Moreira dos Santos",
    author_email="cems@cemshost.com.br",
    license="MIT",
    classifiers=[
        "Development Status :: 5 - Production/Stable",
        "Intended Audience :: Developers",
        "Topic :: Software Development :: Build Tools",
        "Topic :: Software Development :: Quality Assurance",
        "Topic :: Software Development :: Testing",
        "License :: OSI Approved :: MIT License",
        "Programming Language :: Python :: 3",
        "Programming Language :: Python :: 3.6",
        "Programming Language :: Python :: 3.7",
        "Programming Language :: Python :: 3.8",
        "Programming Language :: Python :: 3.9",
        "Programming Language :: Python :: 3.10",
    ],
    keywords="linter check quality",
    packages=["yala"],
    install_requires=[
        "docopt",
        "isort>=5",  # deprecated --recursive flag
        "pycodestyle",
        "pylint",
    ],
    extras_require={
        "all": [
            "mypy",
            "pydocstyle",
            "pyflakes",
            "radon",
        ],
        "flake8": ["flake8", "flake8-polyfill"],
        "mypy": ["mypy"],
        "pydocstyle": ["pydocstyle"],
        "pyflakes": ["pyflakes"],
        "pylint": ["pylint"],
        "radon": ["radon"],
        "black": ["black"],
        "dev": [
            "bandit",
            "coverage",
            "eradicate",
            "rstcheck",
            "safety",
            "tox",
        ],
    },
    package_data={
        "yala": ["setup.cfg", "logging.ini"],
    },
    entry_points={
        "console_scripts": [
            "yala=yala.main:main",
        ],
    },
    test_suite="tests",
)


text:
Comprobación de assert con node js.

##Pasos

Tenemos el siguiente código:
  'use strict';

  var prueba = require('../lib/server');
  var assert = require("assert");

      prueba.comprobacion("EMPRESA01",function(err,resultado){
				  if(!resultado){
					  prueba.insertarEmpresa("EMPRESA01",12);
				  }
				  else{
				  	prueba.comprobacion("EMPRESA01",function(err,resultado){
						  assert.equal(resultado, true);
						  console.log("Assert pasados");
					  });
				  }
				  });

Ejecutamos con node test2.js

![](http://googledrive.com/host/0B6Q-phIC3pUpblVzUS1RbEZjb1E/ejercicio6.png)


text:
size_t strlen(const char*);
void* memcpy(void* __restrict, const void* __restrict, size_t);
void* memset(void*, int, size_t);
void* memmove(void*, const void*, size_t);
int memcmp(const void*, const void*, size_t);

int strcmp(char* str1, char* str2);
char* strcpy(char* dst, const char* src);
char* strcat(char* dst, const char* src);

#endif


text:
export default [
  {
    input: 'follow step-by-step instructions',
    expect: 'Follow Step-by-Step Instructions',
  },
  {
    input: 'this sub-phrase is nice',
    expect: 'This Sub-Phrase Is Nice',
  },
  {
    input: 'catchy title: a subtitle',
    expect: 'Catchy Title: A Subtitle',
  },
  {
    input: 'catchy title: "a quoted subtitle"',
    expect: 'Catchy Title: "A Quoted Subtitle"',
  },
  {
    input: 'catchy title: "'a twice quoted subtitle'"',
    expect: 'Catchy Title: "'A Twice Quoted Subtitle'"',
  },
  {
    input: '"a title inside double quotes"',
    expect: '"A Title Inside Double Quotes"',
  },
  {
    input: 'all words capitalized',
    expect: 'All Words Capitalized',
  },
  {
    input: 'small words are for by and of lowercase',
    expect: 'Small Words Are for by and of Lowercase',
  },
  {
    input: 'a small word starts',
    expect: 'A Small Word Starts',
  },
  {
    input: 'a small word it ends on',
    expect: 'A Small Word It Ends On',
  },
  {
    input: 'do questions work?',
    expect: 'Do Questions Work?',
  },
  {
    input: 'multiple sentences. more than one.',
    expect: 'Multiple Sentences. More Than One.',
  },
  {
    input: 'Ends with small word of',
    expect: 'Ends With Small Word Of',
  },
  {
    input: 'double quoted "inner" word',
    expect: 'Double Quoted "Inner" Word',
  },
  {
    input: "single quoted 'inner' word",
    expect: "Single Quoted 'Inner' Word",
  },
  {
    input: 'fancy double quoted "inner" word',
    expect: 'Fancy Double Quoted "Inner" Word',
  },
  {
    input: 'fancy single quoted 'inner' word',
    expect: 'Fancy Single Quoted 'Inner' Word',
  },
  {
    input: 'this vs. that',
    expect: 'This vs. That',
  },
  {
    input: 'this vs that',
    expect: 'This vs That',
  },
  {
    input: 'this v. that',
    expect: 'This v. That',
  },
  {
    input: 'this v that',
    expect: 'This v That',
  },
  {
    input: 'address email@example.com titles',
    expect: 'Address email@example.com Titles',
  },
  {
    input: 'pass camelCase through',
    expect: 'Pass camelCase Through',
  },
  {
    input: "don't break",
    expect: "Don't Break",
  },
  {
    input: 'catchy title: substance subtitle',
    expect: 'Catchy Title: Substance Subtitle',
  },
  {
    input: 'we keep NASA capitalized',
    expect: 'We Keep NASA Capitalized',
  },
  {
    input: 'leave Q&A unscathed',
    expect: 'Leave Q&A Unscathed',
  },
  {
    input: 'Scott Moritz and TheStreet.com's million iPhone la-la land',
    expect: 'Scott Moritz and TheStreet.com's Million iPhone La-La Land',
  },
  {
    input: 'you have a http://example.com/foo/ title',
    expect: 'You Have a http://example.com/foo/ Title',
  },
  {
    input: 'your hair[cut] looks (nice)',
    expect: 'Your Hair[cut] Looks (Nice)',
  },
  {
    input: 'keep that colo(u)r',
    expect: 'Keep That Colo(u)r',
  },
  {
    input: 'have you read "The Lottery"?',
    expect: 'Have You Read "The Lottery"?',
  },
  {
    input: 'Read markdown_rules.txt to find out how _underscores around words_ will be interpreted',
    expect: 'Read markdown_rules.txt to Find Out How _Underscores Around Words_ Will Be Interpreted',
  },
  {
    input: 'Read markdown_rules.txt to find out how *asterisks around words* will be interpreted',
    expect: 'Read markdown_rules.txt to Find Out How *Asterisks Around Words* Will Be Interpreted',
  },
  {
    input: 'Notes and observations regarding Apple's announcements from 'The Beat Goes On' special event',
    expect: 'Notes and Observations Regarding Apple's Announcements From 'The Beat Goes On' Special Event',
  },
  {
    input: 'Drink this piña colada while you listen to ænima',
    expect: 'Drink This Piña Colada While You Listen to Ænima',
  },
  {
    input: 'capitalize hyphenated words on-demand',
    expect: 'Capitalize Hyphenated Words On-Demand',
  },
  {
    input: 'take them on: special lower cases',
    expect: 'Take Them On: Special Lower Cases',
  },
  {
    input: '
some HTML & entities
',
    expect: '
Some HTML & Entities
',
  },
  {
    input: { toString: () => 'a string' },
    expect: 'A String',
  },
  {
    input: null,
    expect: '',
  },
];


text:
var proxy = Proxy.create({ fix: function() { return {}; } });
Object.preventExtensions(proxy);
Object.observe(proxy, function(){});

var functionProxy = Proxy.createFunction({ fix: function() { return {}; } }, function(){});
Object.preventExtensions(functionProxy);
Object.observe(functionProxy, function(){});


text:
describe("Address Book", function() {

    it("should add contact", function() {
      var addressBook = new AddressBook(),
              contact = new Contact();

      addressBook.addContact(contact);

      expect(addressBook.getContact(0)).toBe(contact);
    });

    it("should delete contact", function() {
      var addressBook = new AddressBook(),
              contact = new Contact();

      addressBook.addContact(contact);
      addressBook.deleteContact(0);

      expect(addressBook.getContact(0)).not.toBeDefined();
    });
});


text:
package signals

import (
	"errors"
	"strconv"
	"strings"

	"github.com/Microsoft/hcsshim/internal/protocol/guestrequest"
	"github.com/Microsoft/hcsshim/internal/protocol/guestresource"
)

var (
	// ErrInvalidSignal is the standard error for an invalid signal for a given
	// flavor of container WCOW/LCOW.
	ErrInvalidSignal = errors.New("invalid signal value")
)

// ValidateSigstrLCOW validates that `sigstr` is an acceptable signal for LCOW
// based on `signalsSupported`.
//
// `sigstr` may either be the text name or integer value of the signal.
//
// If `signalsSupported==false` we verify that only SIGTERM/SIGKILL are sent.
// All other signals are not supported on downlevel platforms.
func ValidateSigstrLCOW(sigstr string, signalsSupported bool) (*guestresource.SignalProcessOptionsLCOW, error) {
	// All flavors including legacy default to SIGTERM on LCOW CtrlC on Windows
	if sigstr == "" {
		if signalsSupported {
			return &guestresource.SignalProcessOptionsLCOW{Signal: sigTerm}, nil
		}
		return nil, nil
	}

	signal, err := strconv.Atoi(sigstr)
	if err == nil {
		return ValidateLCOW(signal, signalsSupported)
	}

	sigstr = strings.ToUpper(sigstr)
	if !signalsSupported {
		// If signals arent supported we just validate that its a known signal.
		// We already return 0 since we only supported a platform Kill() at that
		// time.
		switch sigstr {
		case "TERM", "KILL":
			return nil, nil
		default:
			return nil, ErrInvalidSignal
		}
	}

	// Match signal string name
	for k, v := range signalMapLcow {
		if sigstr == k {
			return &guestresource.SignalProcessOptionsLCOW{Signal: v}, nil
		}
	}
	return nil, ErrInvalidSignal
}

// ValidateSigstrWCOW validates that `sigstr` is an acceptable signal for WCOW
// based on `signalsSupported`.
//
// `sigstr` may either be the text name or integer value of the signal.
//
// If `signalsSupported==false` we verify that only SIGTERM/SIGKILL and
// CTRLSHUTDOWN are sent. All other signals are not supported on downlevel
// platforms.
//
// By default WCOW orchestrators may still use Linux SIGTERM and SIGKILL
// semantics which will be properly translated to CTRLSHUTDOWN and `Terminate`.
// To detect when WCOW needs to `Terminate` the return signal will be `nil` and
// the return error will be `nil`.
func ValidateSigstrWCOW(sigstr string, signalsSupported bool) (*guestresource.SignalProcessOptionsWCOW, error) {
	// All flavors including legacy default to SIGTERM on LCOW CtrlC on Windows
	if sigstr == "" {
		if signalsSupported {
			return &guestresource.SignalProcessOptionsWCOW{Signal: guestrequest.SignalValueWCOWCtrlShutdown}, nil
		}
		return nil, nil
	}

	signal, err := strconv.Atoi(sigstr)
	if err == nil {
		return ValidateWCOW(signal, signalsSupported)
	}

	sigstr = strings.ToUpper(sigstr)
	if !signalsSupported {
		// If signals arent supported we just validate that its a known signal.
		// We already return 0 since we only supported a platform Kill() at that
		// time.
		switch sigstr {
		// Docker sends a UNIX term in the supported Windows Signal map.
		case "CTRLSHUTDOWN", "TERM", "KILL":
			return nil, nil
		default:
			return nil, ErrInvalidSignal
		}
	} else {
		// Docker sends the UNIX signal name or value. Convert them to the
		// correct Windows signals.

		var signalString guestrequest.SignalValueWCOW
		switch sigstr {
		case "CTRLC":
			signalString = guestrequest.SignalValueWCOWCtrlC
		case "CTRLBREAK":
			signalString = guestrequest.SignalValueWCOWCtrlBreak
		case "CTRLCLOSE":
			signalString = guestrequest.SignalValueWCOWCtrlClose
		case "CTRLLOGOFF":
			signalString = guestrequest.SignalValueWCOWCtrlLogOff
		case "CTRLSHUTDOWN", "TERM":
			// SIGTERM is most like CtrlShutdown on Windows convert it here.
			signalString = guestrequest.SignalValueWCOWCtrlShutdown
		case "KILL":
			return nil, nil
		default:
			return nil, ErrInvalidSignal
		}

		return &guestresource.SignalProcessOptionsWCOW{Signal: signalString}, nil
	}
}

// ValidateLCOW validates that `signal` is an acceptable signal for LCOW based
// on `signalsSupported`.
//
// If `signalsSupported==false` we verify that only SIGTERM/SIGKILL are sent.
// All other signals are not supported on downlevel platforms.
func ValidateLCOW(signal int, signalsSupported bool) (*guestresource.SignalProcessOptionsLCOW, error) {
	if !signalsSupported {
		// If signals arent supported we just validate that its a known signal.
		// We already return 0 since we only supported a platform Kill() at that
		// time.
		switch signal {
		case ctrlShutdown, sigTerm, sigKill:
			return nil, nil
		default:
			return nil, ErrInvalidSignal
		}
	}

	// Match signal by value
	for _, v := range signalMapLcow {
		if signal == v {
			return &guestresource.SignalProcessOptionsLCOW{Signal: signal}, nil
		}
	}
	return nil, ErrInvalidSignal
}

// ValidateWCOW validates that `signal` is an acceptable signal for WCOW based
// on `signalsSupported`.
//
// If `signalsSupported==false` we verify that only SIGTERM/SIGKILL and
// CTRLSHUTDOWN are sent. All other signals are not supported on downlevel
// platforms.
//
// By default WCOW orchestrators may still use Linux SIGTERM and SIGKILL
// semantics which will be properly translated to CTRLSHUTDOWN and `Terminate`.
// To detect when WCOW needs to `Terminate` the return signal will be `nil` and
// the return error will be `nil`.
func ValidateWCOW(signal int, signalsSupported bool) (*guestresource.SignalProcessOptionsWCOW, error) {
	if !signalsSupported {
		// If signals arent supported we just validate that its a known signal.
		// We already return 0 since we only supported a platform Kill() at that
		// time.
		switch signal {
		// Docker sends a UNIX term in the supported Windows Signal map.
		case ctrlShutdown, sigTerm, sigKill:
			return nil, nil
		default:
			return nil, ErrInvalidSignal
		}
	} else {
		// Docker sends the UNIX signal name or value. Convert them to the
		// correct Windows signals.

		var signalString guestrequest.SignalValueWCOW
		switch signal {
		case ctrlC:
			signalString = guestrequest.SignalValueWCOWCtrlC
		case ctrlBreak:
			signalString = guestrequest.SignalValueWCOWCtrlBreak
		case ctrlClose:
			signalString = guestrequest.SignalValueWCOWCtrlClose
		case ctrlLogOff:
			signalString = guestrequest.SignalValueWCOWCtrlLogOff
		case ctrlShutdown, sigTerm:
			// sigTerm is most like CtrlShutdown on Windows convert it here.
			signalString = guestrequest.SignalValueWCOWCtrlShutdown
		case sigKill:
			return nil, nil
		default:
			return nil, ErrInvalidSignal
		}

		return &guestresource.SignalProcessOptionsWCOW{Signal: signalString}, nil
	}
}


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

    <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
    <title>Flot Pie Examples</title>

Flot Pie Examples

Default with Legend

		Default pie graph with no options set.

$.plot($("#default"), data,

{

        series: {

            pie: {

                show: true

            }

        }

});

Default without Legend

		Default pie graph when legend is disabled. Since the labels would normally be outside the container, the graph is resized to fit.

$.plot($("#graph1"), data,

{

        series: {

            pie: {

                show: true

            }

        },

        legend: {

            show: false

        }

});

Graph2

		Added a semi-transparent background to the labels and a custom labelFormatter function.

$.plot($("#graph2"), data,

{

        series: {

            pie: {

                show: true,

                radius: 1,

                label: {

                    show: true,

                    radius: 1,

                    formatter: function(label, series){

                        return '<div style="font-size:8pt;text-align:center;padding:2px;color:white;">'+label+'<br/>'+Math.round(series.percent)+'%</div>';

                    },

                    background: { opacity: 0.8 }

                }

            }

        },

        legend: {

            show: false

        }

});

Graph3

		Slightly more transparent label backgrounds and adjusted the radius values to place them within the pie.

$.plot($("#graph3"), data,

{

        series: {

            pie: {

                show: true,

                radius: 1,

                label: {

                    show: true,

                    radius: 3/4,

                    formatter: function(label, series){

                        return '<div style="font-size:8pt;text-align:center;padding:2px;color:white;">'+label+'<br/>'+Math.round(series.percent)+'%</div>';

                    },

                    background: { opacity: 0.5 }

                }

            }

        },

        legend: {

            show: false

        }

});

Graph4

		Semi-transparent, black-colored label background.

$.plot($("#graph4"), data,

{

        series: {

            pie: {

                show: true,

                radius: 1,

                label: {

                    show: true,

                    radius: 3/4,

                    formatter: function(label, series){

                        return '<div style="font-size:8pt;text-align:center;padding:2px;color:white;">'+label+'<br/>'+Math.round(series.percent)+'%</div>';

                    },

                    background: {

                        opacity: 0.5,

                        color: '#000'

                    }

                }

            },

        legend: {

            show: false

        }

});

Graph5

		Semi-transparent, black-colored label background placed at pie edge.

$.plot($("#graph5"), data,

{

        series: {

            pie: {

                show: true,

                radius: 3/4,

                label: {

                    show: true,

                    radius: 3/4,

                    formatter: function(label, series){

                        return '<div style="font-size:8pt;text-align:center;padding:2px;color:white;">'+label+'<br/>'+Math.round(series.percent)+'%</div>';

                    },

                    background: {

                        opacity: 0.5,

                        color: '#000'

                    }

                }

            },

        legend: {

            show: false

        }

});

Graph6

		Labels can be hidden if the slice is less than a given percentage of the pie (10% in this case).

$.plot($("#graph6"), data,

{

        series: {

            pie: {

                show: true,

                radius: 1,

                label: {

                    show: true,

                    radius: 2/3,

                    formatter: function(label, series){

                        return '<div style="font-size:8pt;text-align:center;padding:2px;color:white;">'+label+'<br/>'+Math.round(series.percent)+'%</div>';

                    },

                    threshold: 0.1

                }

            }

        },

        legend: {

            show: false

        }

});

Graph7

		All slices less than a given percentage of the pie can be combined into a single, larger slice (10% in this case).

Note: you may need to refresh the page to see this effect.

$.plot($("#graph7"), data,

{

        series: {

            pie: {

                show: true,

                combine: {

                    color: '#999',

                    threshold: 0.1

                }

            }

        },

        legend: {

            show: false

        }

});

Graph8

		The radius can also be set to a specific size (even larger than the container itself).

$.plot($("#graph8"), data,

{

        series: {

            pie: {

                show: true,

                radius:300,

                label: {

                    show: true,

                    formatter: function(label, series){

                        return '<div style="font-size:8pt;text-align:center;padding:2px;color:white;">'+label+'<br/>'+Math.round(series.percent)+'%</div>';

                    },

                    threshold: 0.1

                }

            }

        },

        legend: {

            show: false

        }

});

Graph9

		The pie can be tilted at an angle.

$.plot($("#graph9"), data,

{

        series: {

            pie: {

                show: true,

                radius: 1,

                tilt: 0.5,

                label: {

                    show: true,

                    radius: 1,

                    formatter: function(label, series){

                        return '<div style="font-size:8pt;text-align:center;padding:2px;color:white;">'+label+'<br/>'+Math.round(series.percent)+'%</div>';

                    },

                    background: { opacity: 0.8 }

                },

                combine: {

                    color: '#999',

                    threshold: 0.1

                }

            }

        },

        legend: {

            show: false

        }

});

Donut

		A donut hole can be added.

$.plot($("#donut"), data,

{

        series: {

            pie: {

                innerRadius: 0.5,

                show: true

            }

        }

});

Interactive

		The pie can be made interactive with hover and click events.

$.plot($("#interactive"), data,

{

        series: {

            pie: {

                show: true

            }

        },

        grid: {

            hoverable: true,

            clickable: true

        }

});

$("#interactive").bind("plothover", pieHover);

$("#interactive").bind("plotclick", pieClick);

Pie Options

option: default value - Description of option

show: false - Enable the plugin and draw as a pie.

radius: 'auto' - Sets the radius of the pie. If value is between 0 and 1 (inclusive) then it will use that as a percentage of the available space (size of the container), otherwise it will use the value as a direct pixel length. If set to 'auto', it will be set to 1 if the legend is enabled and 3/4 if not.

innerRadius: 0 - Sets the radius of the donut hole. If value is between 0 and 1 (inclusive) then it will use that as a percentage of the radius, otherwise it will use the value as a direct pixel length.

startAngle: 3/2 - Factor of PI used for the starting angle (in radians) It can range between 0 and 2 (where 0 and 2 have the same result).

tilt: 1 - Percentage of tilt ranging from 0 and 1, where 1 has no change (fully vertical) and 0 is completely flat (fully horizontal -- in which case nothing actually gets drawn).

offset:

top: 0 - Pixel distance to move the pie up and down (relative to the center).

left: 'auto' - Pixel distance to move the pie left and right (relative to the center).

stroke:

color: '#FFF' - Color of the border of each slice. Hexadecimal color definitions are prefered (other formats may or may not work).

width: 1 - Pixel width of the border of each slice.

label:

show: 'auto' - Enable/Disable the labels. This can be set to true, false, or 'auto'. When set to 'auto', it will be set to false if the legend is enabled and true if not.

radius: 1 - Sets the radius at which to place the labels. If value is between 0 and 1 (inclusive) then it will use that as a percentage of the available space (size of the container), otherwise it will use the value as a direct pixel length.

threshold: 0 - Hides the labels of any pie slice that is smaller than the specified percentage (ranging from 0 to 1) i.e. a value of '0.03' will hide all slices 3% or less of the total.

formatter: [function] - This function specifies how the positioned labels should be formatted, and is applied after the legend's labelFormatter function. The labels can also still be styled using the class "pieLabel" (i.e. ".pieLabel" or "#graph1 .pieLabel").

radius: 1 - Sets the radius at which to place the labels. If value is between 0 and 1 (inclusive) then it will use that as a percentage of the available space (size of the container), otherwise it will use the value as a direct pixel length.

background:

color: null - Backgound color of the positioned labels. If null, the plugin will automatically use the color of the slice.

opacity: 0 - Opacity of the background for the positioned labels. Acceptable values range from 0 to 1, where 0 is completely transparent and 1 is completely opaque.

combine:

threshold: 0 - Combines all slices that are smaller than the specified percentage (ranging from 0 to 1) i.e. a value of '0.03' will combine all slices 3% or less into one slice).

color: null - Backgound color of the positioned labels. If null, the plugin will automatically use the color of the first slice to be combined.

label: 'Other' - Label text for the combined slice.

highlight:

opacity: 0.5 - Opacity of the highlight overlay on top of the current pie slice. Currently this just uses a white overlay, but support for changing the color of the overlay will also be added at a later date.

Changes/Features

v1.0 - November 20th, 2009 - Brian Medendorp

The pie plug-in is now part of the Flot repository! This should make it a lot easier to deal with.

Added a new option (innerRadius) to add a "donut hole" to the center of the pie, based on comtributions from Anthony Aragues. I was a little reluctant to add this feature because it doesn't work very well with the shadow created for the tilted pie, but figured it was worthwhile for non-tilted pies. Also, excanvas apparently doesn't support compositing, so it will fall back to using the stroke color to fill in the center (but I recommend setting the stroke color to the background color anyway).

Changed the lineJoin for the border of the pie slices to use the 'round' option. This should make the center of the pie look better, particularly when there are numerous thin slices.

Included a bug fix submitted by btburnett3 to display a slightly smaller slice in the event that the slice is 100% and being rendered with Internet Explorer. I haven't experienced this bug myself, but it doesn't seem to hurt anything so I've included it.

The tilt value is now used when calculating the maximum radius of the pie in relation to the height of the container. This should prevent the pie from being smaller than it needed to in some cases, as well as reducing the amount of extra white space generated above and below the pie.

Hover and Click functionality are now availabe!

Thanks to btburnett3 for the original hover functionality and Anthony Aragues for the modification that makes it compatable with excanvas, this was a huge help!

Added a new option (highlight opacity) to modify the highlight created when mousing over a slice. Currently this just uses a white overlay, but an option to change the hightlight color will be added when the appropriate functionality becomes available.

I had a major setback that required me to practically rebuild the hover/click events from scratch one piece at a time (I discovered that it only worked with a single pie on a page at a time), but the end result ended up being virtually identical to the original, so I'm not quite sure what exactly made it work.

Warning: There are some minor issues with using this functionality in conjuction with some of the other more advanced features (tilt and donut). When using a donut hole, the inner portion still triggers the events even though that portion of the pie is no longer visible. When tilted, the interactive portions still use the original, untilted version of the pie when determining mouse position (this is because the isPointInPath function apparently doesn't work with transformations), however hover and click both work this way, so the appropriate slice is still highlighted when clicking, and it isn't as noticable of a problem.

Included a bug fix submitted by Xavi Ivars to fix array issues when other javascript libraries are included in addition to jQuery

v0.4 - July 1st, 2009 - Brian Medendorp

Each series will now be shown in the legend, even if it's value is zero. The series will not get a positioned label because it will overlap with the other labels present and often makes them unreadable.

Data can now be passed in using the standard Flot method using an array of datapoints, the pie plugin will simply use the first y-value that it finds for each series in this case. The plugin uses this datastructure internally, but you can still use the old method of passing in a single numerical value for each series (the plugin will convert it as necessary). This should make it easier to transition from other types of graphs (such as a stacked bar graph) to a pie.

The pie can now be tilted at an angle with a new "tilt" option. Acceptable values range from 0-1, where 1 has no change (fully vertical) and 0 is completely flat (fully horizontal -- in which case nothing actually gets drawn). If the plugin determines that it will fit within the canvas, a drop shadow will be drawn under the tilted pie (this also requires a tilt value of 0.8 or less).

v0.3.2 - June 25th, 2009 - Brian Medendorp

Fixed a bug that was causing the pie to be shifted too far left or right when the legend is showing in some cases.

v0.3.1 - June 24th, 2009 - Brian Medendorp

Fixed a bug that was causing nothing to be drawn and generating a javascript error if any of the data values were set to zero.

v0.3 - June 23rd, 2009 - Brian Medendorp

The legend now works without any modifications! Because of changes made to flot and the plugin system (thanks Ole Laursen!) I was able to simplify a number of things and am now able to use the legend without the direct access hack that was required in the previous version.

v0.2 - June 22nd, 2009 - Brian Medendorp

The legend now works but only if you make the necessary changes to jquery.flot.js. Because of this, I changed the default values for pie.radius and pie.label.show to new 'auto' settings that change the default behavior of the size and labels depending on whether the legend functionality is available or not.

v0.1 - June 18th, 2009 - Brian Medendorp

Rewrote the entire pie code into a flot plugin (since that is now an option), so it should be much easier to use and the code is cleaned up a bit. However, the (standard flot) legend is no longer available because the only way to prevent the grid lines from being displayed also prevents the legend from being displayed. Hopefully this can be fixed at a later date.

Restructured and combined some of the options. It should be much easier to deal with now.

Added the ability to change the starting point of the pie (still defaults to the top).

Modified the default options to show the labels to compensate for the lack of a legend.

Modified this page to use a random dataset. Note: you may need to refresh the page to see the effects of some of the examples.

May 21st, 2009 - Brian Medendorp

Merged original pie modifications by Sergey Nosenko into the latest SVN version (as of May 15th, 2009) so that it will work with ie8.

Pie graph will now be centered in the canvas unless moved because of the legend or manually via the options. Additionally it prevents the pie from being moved beyond the edge of the canvas.

Modified the code related to the labelFormatter option to apply flot's legend labelFormatter first. This is so that the labels will be consistent, but still provide extra formatting for the positioned labels (such as adding the percentage value).

Positioned labels now have their backgrounds applied as a seperate element (much like the legend background) so that the opacity value can be set independently from the label itself (foreground). Additionally, the background color defaults to that of the matching slice.

As long as the labelOffset and radiusLimit are not set to hard values, the pie will be shrunk if the labels will extend outside the edge of the canvas

Added new options "radiusLimitFactor" and "radiusLimit" which limits how large the (visual) radius of the pie is in relation to the full radius (as calculated from the canvas dimensions) or a hard-pixel value (respectively). This allows for pushing the labels "outside" the pie.

Added a new option "labelHidePercent" that does not show the positioned labels of slices smaller than the specified percentage. This is to help prevent a bunch of overlapping labels from small slices.

Added a new option "sliceCombinePercent" that combines all slices smaller than the specified percentage into one larger slice. This is to help make the pie more attractive when there are a number of tiny slices. The options "sliceCombineColor" and "sliceCombineLabel" have also been added to change the color and name of the new slice if desired.

Tested in Firefox (3.0.10, 3.5b4), Internet Explorer (6.0.2900, 7.0.5730, 8.0.6001), Chrome (1.0.154), Opera (9.64), and Safari (3.1.1, 4 beta 5528.16).


text:
import astropy.coordinates as coord

# This package
from ..galactocentric import get_galactocentric2019

def test_simple():
    # Not meant to be a sensible test - that's done in Astropy!
    fr = get_galactocentric2019()
    assert isinstance(fr, coord.Galactocentric)