jab2870/Vim-Vixen
Archived
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Make key class

Browse source
This commit is contained in:
Shin'ya UEOKA 2019-10-03 12:15:12 +00:00
parent 620d4bc03e
commit 62a86c5253
8 changed files with 193 additions and 167 deletions
Download patch file Download diff file Expand all files Collapse all files

4
src/content/InputDriver.ts
View file

@ -1,5 +1,5 @@
import * as dom from '../shared/utils/dom'; import * as dom from '../shared/utils/dom';
import Key, * as keys from './domains/Key'; import Key from './domains/Key';
const cancelKey = (e: KeyboardEvent): boolean => { const cancelKey = (e: KeyboardEvent): boolean => {
if (e.key === 'Escape') { if (e.key === 'Escape') {
@ -66,7 +66,7 @@ export default class InputDriver {
return; return;
} }
let key = keys.fromKeyboardEvent(e); let key = Key.fromKeyboardEvent(e);
for (let listener of this.onKeyListeners) { for (let listener of this.onKeyListeners) {
let stop = listener(key); let stop = listener(key);
if (stop) { if (stop) {

2
src/content/client/FollowMasterClient.ts
View file

@ -35,7 +35,7 @@ export class FollowMasterClientImpl implements FollowMasterClient {
this.postMessage({ this.postMessage({
type: messages.FOLLOW_KEY_PRESS, type: messages.FOLLOW_KEY_PRESS,
key: key.key, key: key.key,
ctrlKey: key.ctrlKey || false, ctrlKey: key.ctrl || false,
}); });
} }

133
src/content/domains/Key.ts
View file

@ -1,11 +1,3 @@
export default interface Key {
key: string;
shiftKey?: boolean;
ctrlKey?: boolean;
altKey?: boolean;
metaKey?: boolean;
}
const modifiedKeyName = (name: string): string => { const modifiedKeyName = (name: string): string => {
if (name === ' ') { if (name === ' ') {
return 'Space'; return 'Space';
@ -18,55 +10,84 @@ const modifiedKeyName = (name: string): string => {
return name; return name;
}; };
export const fromKeyboardEvent = (e: KeyboardEvent): Key => { export default class Key {
let key = modifiedKeyName(e.key); public readonly key: string;
let shift = e.shiftKey;
if (key.length === 1 && key.toUpperCase() === key.toLowerCase()) { public readonly shift: boolean;
// make shift false for symbols to enable key bindings by symbold keys.
// But this limits key bindings by symbol keys with Shift (such as Shift+$>. public readonly ctrl: boolean;
shift = false;
public readonly alt: boolean;
public readonly meta: boolean;
constructor({ key, shift, ctrl, alt, meta }: {
key: string;
shift: boolean;
ctrl: boolean;
alt: boolean;
meta: boolean;
}) {
this.key = key;
this.shift = shift;
this.ctrl = ctrl;
this.alt = alt;
this.meta = meta;
} }
return { static fromMapKey(str: string): Key {
key: modifiedKeyName(e.key), if (str.startsWith('<') && str.endsWith('>')) {
shiftKey: shift, let inner = str.slice(1, -1);
ctrlKey: e.ctrlKey, let shift = inner.includes('S-');
altKey: e.altKey, let base = inner.slice(inner.lastIndexOf('-') + 1);
metaKey: e.metaKey, if (shift && base.length === 1) {
}; base = base.toUpperCase();
}; } else if (!shift && base.length === 1) {
base = base.toLowerCase();
export const fromMapKey = (key: string): Key => { }
if (key.startsWith('<') && key.endsWith('>')) { return new Key({
let inner = key.slice(1, -1); key: base,
let shift = inner.includes('S-'); shift: shift,
let base = inner.slice(inner.lastIndexOf('-') + 1); ctrl: inner.includes('C-'),
if (shift && base.length === 1) { alt: inner.includes('A-'),
base = base.toUpperCase(); meta: inner.includes('M-'),
} else if (!shift && base.length === 1) { });
base = base.toLowerCase();
} }
return {
key: base,
shiftKey: inner.includes('S-'),
ctrlKey: inner.includes('C-'),
altKey: inner.includes('A-'),
metaKey: inner.includes('M-'),
};
}
return {
key: key,
shiftKey: key.toLowerCase() !== key,
ctrlKey: false,
altKey: false,
metaKey: false,
};
};
export const equals = (e1: Key, e2: Key): boolean => { return new Key({
return e1.key === e2.key && key: str,
e1.ctrlKey === e2.ctrlKey && shift: str.toLowerCase() !== str,
e1.metaKey === e2.metaKey && ctrl: false,
e1.altKey === e2.altKey && alt: false,
e1.shiftKey === e2.shiftKey; meta: false,
}; });
}
static fromKeyboardEvent(e: KeyboardEvent): Key {
let key = modifiedKeyName(e.key);
let shift = e.shiftKey;
if (key.length === 1 && key.toUpperCase() === key.toLowerCase()) {
// make shift false for symbols to enable key bindings by symbold keys.
// But this limits key bindings by symbol keys with Shift
// (such as Shift+$>.
shift = false;
}
return new Key({
key: modifiedKeyName(e.key),
shift: shift,
ctrl: e.ctrlKey,
alt: e.altKey,
meta: e.metaKey,
});
}
equals(key: Key) {
return this.key === key.key &&
this.ctrl === key.ctrl &&
this.meta === key.meta &&
this.alt === key.alt &&
this.shift === key.shift;
}
}

6
src/content/domains/KeySequence.ts
View file

@ -1,4 +1,4 @@
import Key, * as keyUtils from './Key'; import Key from './Key';
export default class KeySequence { export default class KeySequence {
private keys: Key[]; private keys: Key[];
@ -24,7 +24,7 @@ export default class KeySequence {
return false; return false;
} }
for (let i = 0; i < o.keys.length; ++i) { for (let i = 0; i < o.keys.length; ++i) {
if (!keyUtils.equals(this.keys[i], o.keys[i])) { if (!this.keys[i].equals(o.keys[i])) {
return false; return false;
} }
} }
@ -54,7 +54,7 @@ export const fromMapKeys = (keys: string): KeySequence => {
return fromMapKeysRecursive( return fromMapKeysRecursive(
remainings.slice(nextPos), remainings.slice(nextPos),
mappedKeys.concat([keyUtils.fromMapKey(remainings.slice(0, nextPos))]) mappedKeys.concat([Key.fromMapKey(remainings.slice(0, nextPos))])
); );
}; };

18
test/content/InputDriver.test.ts
View file

@ -21,10 +21,10 @@ describe('InputDriver', () => {
it('register callbacks', (done) => { it('register callbacks', (done) => {
driver.onKey((key: Key): boolean => { driver.onKey((key: Key): boolean => {
expect(key.key).to.equal('a'); expect(key.key).to.equal('a');
expect(key.ctrlKey).to.be.true; expect(key.ctrl).to.be.true;
expect(key.shiftKey).to.be.false; expect(key.shift).to.be.false;
expect(key.altKey).to.be.false; expect(key.alt).to.be.false;
expect(key.metaKey).to.be.false; expect(key.meta).to.be.false;
done(); done();
return true; return true;
}); });
@ -68,15 +68,15 @@ describe('InputDriver', () => {
it('propagates and stop handler chain', () => { it('propagates and stop handler chain', () => {
let a = 0, b = 0, c = 0; let a = 0, b = 0, c = 0;
driver.onKey((key: Key): boolean => { driver.onKey((_key: Key): boolean => {
a++; a++;
return false; return false;
}); });
driver.onKey((key: Key): boolean => { driver.onKey((_key: Key): boolean => {
b++; b++;
return true; return true;
}); });
driver.onKey((key: Key): boolean => { driver.onKey((_key: Key): boolean => {
c++; c++;
return true; return true;
}); });
@ -89,7 +89,7 @@ describe('InputDriver', () => {
}) })
it('does not invoke only meta keys', () => { it('does not invoke only meta keys', () => {
driver.onKey((key: Key): boolean=> { driver.onKey((_key: Key): boolean=> {
expect.fail(); expect.fail();
return false; return false;
}); });
@ -115,7 +115,7 @@ describe('InputDriver', () => {
it('ignores events from contenteditable elements', () => { it('ignores events from contenteditable elements', () => {
let div = window.document.createElement('div'); let div = window.document.createElement('div');
let driver = new InputDriver(div); let driver = new InputDriver(div);
driver.onKey((key: Key): boolean => { driver.onKey((_key: Key): boolean => {
expect.fail(); expect.fail();
return false; return false;
}); });

140
test/content/domains/Key.test.ts
View file

@ -1,137 +1,139 @@
import Key, * as keys from '../../../src/content/domains/Key'; import Key from '../../../src/content/domains/Key';
import { expect } from 'chai' import { expect } from 'chai'
describe("Key", () => { describe("Key", () => {
describe('fromKeyboardEvent', () => { describe('fromKeyboardEvent', () => {
it('returns from keyboard input Ctrl+X', () => { it('returns from keyboard input Ctrl+X', () => {
let k = keys.fromKeyboardEvent(new KeyboardEvent('keydown', { let k = Key.fromKeyboardEvent(new KeyboardEvent('keydown', {
key: 'x', shiftKey: false, ctrlKey: true, altKey: false, metaKey: true, key: 'x', shiftKey: false, ctrlKey: true, altKey: false, metaKey: true,
})); }));
expect(k.key).to.equal('x'); expect(k.key).to.equal('x');
expect(k.shiftKey).to.be.false; expect(k.shift).to.be.false;
expect(k.ctrlKey).to.be.true; expect(k.ctrl).to.be.true;
expect(k.altKey).to.be.false; expect(k.alt).to.be.false;
expect(k.metaKey).to.be.true; expect(k.meta).to.be.true;
}); });
it('returns from keyboard input Shift+Esc', () => { it('returns from keyboard input Shift+Esc', () => {
let k = keys.fromKeyboardEvent(new KeyboardEvent('keydown', { let k = Key.fromKeyboardEvent(new KeyboardEvent('keydown', {
key: 'Escape', shiftKey: true, ctrlKey: false, altKey: false, metaKey: true key: 'Escape', shiftKey: true, ctrlKey: false, altKey: false, metaKey: true
})); }));
expect(k.key).to.equal('Esc'); expect(k.key).to.equal('Esc');
expect(k.shiftKey).to.be.true; expect(k.shift).to.be.true;
expect(k.ctrlKey).to.be.false; expect(k.ctrl).to.be.false;
expect(k.altKey).to.be.false; expect(k.alt).to.be.false;
expect(k.metaKey).to.be.true; expect(k.meta).to.be.true;
}); });
it('returns from keyboard input Ctrl+$', () => { it('returns from keyboard input Ctrl+$', () => {
// $ required shift pressing on most keyboards // $ required shift pressing on most keyboards
let k = keys.fromKeyboardEvent(new KeyboardEvent('keydown', { let k = Key.fromKeyboardEvent(new KeyboardEvent('keydown', {
key: '$', shiftKey: true, ctrlKey: true, altKey: false, metaKey: false key: '$', shiftKey: true, ctrlKey: true, altKey: false, metaKey: false
})); }));
expect(k.key).to.equal('$'); expect(k.key).to.equal('$');
expect(k.shiftKey).to.be.false; expect(k.shift).to.be.false;
expect(k.ctrlKey).to.be.true; expect(k.ctrl).to.be.true;
expect(k.altKey).to.be.false; expect(k.alt).to.be.false;
expect(k.metaKey).to.be.false; expect(k.meta).to.be.false;
}); });
it('returns from keyboard input Crtl+Space', () => { it('returns from keyboard input Crtl+Space', () => {
let k = keys.fromKeyboardEvent(new KeyboardEvent('keydown', { let k = Key.fromKeyboardEvent(new KeyboardEvent('keydown', {
key: ' ', shiftKey: false, ctrlKey: true, altKey: false, metaKey: false key: ' ', shiftKey: false, ctrlKey: true, altKey: false, metaKey: false
})); }));
expect(k.key).to.equal('Space'); expect(k.key).to.equal('Space');
expect(k.shiftKey).to.be.false; expect(k.shift).to.be.false;
expect(k.ctrlKey).to.be.true; expect(k.ctrl).to.be.true;
expect(k.altKey).to.be.false; expect(k.alt).to.be.false;
expect(k.metaKey).to.be.false; expect(k.meta).to.be.false;
}); });
}); });
describe('fromMapKey', () => { describe('fromMapKey', () => {
it('return for X', () => { it('return for X', () => {
let key = keys.fromMapKey('x'); let key = Key.fromMapKey('x');
expect(key.key).to.equal('x'); expect(key.key).to.equal('x');
expect(key.shiftKey).to.be.false; expect(key.shift).to.be.false;
expect(key.ctrlKey).to.be.false; expect(key.ctrl).to.be.false;
expect(key.altKey).to.be.false; expect(key.alt).to.be.false;
expect(key.metaKey).to.be.false; expect(key.meta).to.be.false;
}); });
it('return for Shift+X', () => { it('return for Shift+X', () => {
let key = keys.fromMapKey('X'); let key = Key.fromMapKey('X');
expect(key.key).to.equal('X'); expect(key.key).to.equal('X');
expect(key.shiftKey).to.be.true; expect(key.shift).to.be.true;
expect(key.ctrlKey).to.be.false; expect(key.ctrl).to.be.false;
expect(key.altKey).to.be.false; expect(key.alt).to.be.false;
expect(key.metaKey).to.be.false; expect(key.meta).to.be.false;
}); });
it('return for Ctrl+X', () => { it('return for Ctrl+X', () => {
let key = keys.fromMapKey('<C-X>'); let key = Key.fromMapKey('<C-X>');
expect(key.key).to.equal('x'); expect(key.key).to.equal('x');
expect(key.shiftKey).to.be.false; expect(key.shift).to.be.false;
expect(key.ctrlKey).to.be.true; expect(key.ctrl).to.be.true;
expect(key.altKey).to.be.false; expect(key.alt).to.be.false;
expect(key.metaKey).to.be.false; expect(key.meta).to.be.false;
}); });
it('returns for Ctrl+Meta+X', () => { it('returns for Ctrl+Meta+X', () => {
let key = keys.fromMapKey('<C-M-X>'); let key = Key.fromMapKey('<C-M-X>');
expect(key.key).to.equal('x'); expect(key.key).to.equal('x');
expect(key.shiftKey).to.be.false; expect(key.shift).to.be.false;
expect(key.ctrlKey).to.be.true; expect(key.ctrl).to.be.true;
expect(key.altKey).to.be.false; expect(key.alt).to.be.false;
expect(key.metaKey).to.be.true; expect(key.meta).to.be.true;
}); });
it('returns for Ctrl+Shift+x', () => { it('returns for Ctrl+Shift+x', () => {
let key = keys.fromMapKey('<C-S-x>'); let key = Key.fromMapKey('<C-S-x>');
expect(key.key).to.equal('X'); expect(key.key).to.equal('X');
expect(key.shiftKey).to.be.true; expect(key.shift).to.be.true;
expect(key.ctrlKey).to.be.true; expect(key.ctrl).to.be.true;
expect(key.altKey).to.be.false; expect(key.alt).to.be.false;
expect(key.metaKey).to.be.false; expect(key.meta).to.be.false;
}); });
it('returns for Shift+Esc', () => { it('returns for Shift+Esc', () => {
let key = keys.fromMapKey('<S-Esc>'); let key = Key.fromMapKey('<S-Esc>');
expect(key.key).to.equal('Esc'); expect(key.key).to.equal('Esc');
expect(key.shiftKey).to.be.true; expect(key.shift).to.be.true;
expect(key.ctrlKey).to.be.false; expect(key.ctrl).to.be.false;
expect(key.altKey).to.be.false; expect(key.alt).to.be.false;
expect(key.metaKey).to.be.false; expect(key.meta).to.be.false;
}); });
it('returns for Ctrl+Esc', () => { it('returns for Ctrl+Esc', () => {
let key = keys.fromMapKey('<C-Esc>'); let key = Key.fromMapKey('<C-Esc>');
expect(key.key).to.equal('Esc'); expect(key.key).to.equal('Esc');
expect(key.shiftKey).to.be.false; expect(key.shift).to.be.false;
expect(key.ctrlKey).to.be.true; expect(key.ctrl).to.be.true;
expect(key.altKey).to.be.false; expect(key.alt).to.be.false;
expect(key.metaKey).to.be.false; expect(key.meta).to.be.false;
}); });
it('returns for Ctrl+Esc', () => { it('returns for Ctrl+Esc', () => {
let key = keys.fromMapKey('<C-Space>'); let key = Key.fromMapKey('<C-Space>');
expect(key.key).to.equal('Space'); expect(key.key).to.equal('Space');
expect(key.shiftKey).to.be.false; expect(key.shift).to.be.false;
expect(key.ctrlKey).to.be.true; expect(key.ctrl).to.be.true;
expect(key.altKey).to.be.false; expect(key.alt).to.be.false;
expect(key.metaKey).to.be.false; expect(key.meta).to.be.false;
}); });
}); });
describe('equals', () => { describe('equals', () => {
expect(keys.equals( expect(new Key({
{ key: 'x', ctrlKey: true, }, key: 'x', shift: false, ctrl: true, alt: false, meta: false,
{ key: 'x', ctrlKey: true, }, }).equals(new Key({
)).to.be.true; key: 'x', shift: false, ctrl: true, alt: false, meta: false,
}))).to.be.true;
expect(keys.equals( expect(new Key({
{ key: 'X', shiftKey: true, }, key: 'x', shift: false, ctrl: false, alt: false, meta: false,
{ key: 'x', ctrlKey: true, }, }).equals(new Key({
)).to.be.false; key: 'X', shift: true, ctrl: false, alt: false, meta: false,
}))).to.be.false;
}); });
}); });

35
test/content/domains/KeySequence.test.ts
View file

@ -1,48 +1,50 @@
import KeySequence, * as utils from '../../../src/content/domains/KeySequence'; import KeySequence, * as utils from '../../../src/content/domains/KeySequence';
import Key from '../../../src/content/domains/Key';
import { expect } from 'chai' import { expect } from 'chai'
describe("KeySequence", () => { describe("KeySequence", () => {
describe('#push', () => { describe('#push', () => {
it('append a key to the sequence', () => { it('append a key to the sequence', () => {
let seq = KeySequence.from([]); let seq = KeySequence.from([]);
seq.push({ key: 'g' }); seq.push(Key.fromMapKey('g'));
seq.push({ key: 'u', shiftKey: true }); seq.push(Key.fromMapKey('<S-U>'));
let array = seq.getKeyArray(); let array = seq.getKeyArray();
expect(array[0]).to.deep.equal({ key: 'g' }); expect(array[0].key).to.equal('g');
expect(array[1]).to.deep.equal({ key: 'u', shiftKey: true }); expect(array[1].key).to.equal('U');
expect(array[1].shift).to.be.true;
}) })
}); });
describe('#startsWith', () => { describe('#startsWith', () => {
it('returns true if the key sequence starts with param', () => { it('returns true if the key sequence starts with param', () => {
let seq = KeySequence.from([ let seq = KeySequence.from([
{ key: 'g' }, Key.fromMapKey('g'),
{ key: 'u', shiftKey: true }, Key.fromMapKey('<S-U>'),
]); ]);
expect(seq.startsWith(KeySequence.from([ expect(seq.startsWith(KeySequence.from([
]))).to.be.true; ]))).to.be.true;
expect(seq.startsWith(KeySequence.from([ expect(seq.startsWith(KeySequence.from([
{ key: 'g' }, Key.fromMapKey('g'),
]))).to.be.true; ]))).to.be.true;
expect(seq.startsWith(KeySequence.from([ expect(seq.startsWith(KeySequence.from([
{ key: 'g' }, { key: 'u', shiftKey: true }, Key.fromMapKey('g'), Key.fromMapKey('<S-U>'),
]))).to.be.true; ]))).to.be.true;
expect(seq.startsWith(KeySequence.from([ expect(seq.startsWith(KeySequence.from([
{ key: 'g' }, { key: 'u', shiftKey: true }, { key: 'x' }, Key.fromMapKey('g'), Key.fromMapKey('<S-U>'), Key.fromMapKey('x'),
]))).to.be.false; ]))).to.be.false;
expect(seq.startsWith(KeySequence.from([ expect(seq.startsWith(KeySequence.from([
{ key: 'h' }, Key.fromMapKey('h'),
]))).to.be.false; ]))).to.be.false;
}) });
it('returns true if the empty sequence starts with an empty sequence', () => { it('returns true if the empty sequence starts with an empty sequence', () => {
let seq = KeySequence.from([]); let seq = KeySequence.from([]);
expect(seq.startsWith(KeySequence.from([]))).to.be.true; expect(seq.startsWith(KeySequence.from([]))).to.be.true;
expect(seq.startsWith(KeySequence.from([ expect(seq.startsWith(KeySequence.from([
{ key: 'h' }, Key.fromMapKey('h'),
]))).to.be.false; ]))).to.be.false;
}) })
}); });
@ -52,21 +54,20 @@ describe("KeySequence", () => {
let keyArray = utils.fromMapKeys('<S-Esc>').getKeyArray(); let keyArray = utils.fromMapKeys('<S-Esc>').getKeyArray();
expect(keyArray).to.have.lengthOf(1); expect(keyArray).to.have.lengthOf(1);
expect(keyArray[0].key).to.equal('Esc'); expect(keyArray[0].key).to.equal('Esc');
expect(keyArray[0].shiftKey).to.be.true; expect(keyArray[0].shift).to.be.true;
}); });
it('returns mapped keys for a<C-B><A-C>d<M-e>', () => { it('returns mapped keys for a<C-B><A-C>d<M-e>', () => {
let keyArray = utils.fromMapKeys('a<C-B><A-C>d<M-e>').getKeyArray(); let keyArray = utils.fromMapKeys('a<C-B><A-C>d<M-e>').getKeyArray();
expect(keyArray).to.have.lengthOf(5); expect(keyArray).to.have.lengthOf(5);
expect(keyArray[0].key).to.equal('a'); expect(keyArray[0].key).to.equal('a');
expect(keyArray[1].ctrlKey).to.be.true; expect(keyArray[1].ctrl).to.be.true;
expect(keyArray[1].key).to.equal('b'); expect(keyArray[1].key).to.equal('b');
expect(keyArray[2].altKey).to.be.true; expect(keyArray[2].alt).to.be.true;
expect(keyArray[2].key).to.equal('c'); expect(keyArray[2].key).to.equal('c');
expect(keyArray[3].key).to.equal('d'); expect(keyArray[3].key).to.equal('d');
expect(keyArray[4].metaKey).to.be.true; expect(keyArray[4].meta).to.be.true;
expect(keyArray[4].key).to.equal('e'); expect(keyArray[4].key).to.equal('e');
}); });
}) })
}); });

22
test/content/repositories/KeymapRepository.test.ts
View file

@ -1,5 +1,6 @@
import KeymapRepository, { KeymapRepositoryImpl } import KeymapRepository, { KeymapRepositoryImpl }
from '../../../src/content/repositories/KeymapRepository'; from '../../../src/content/repositories/KeymapRepository';
import Key from '../../../src/content/domains/Key'
import { expect } from 'chai'; import { expect } from 'chai';
describe('KeymapRepositoryImpl', () => { describe('KeymapRepositoryImpl', () => {
@ -11,24 +12,25 @@ describe('KeymapRepositoryImpl', () => {
describe('#enqueueKey()', () => { describe('#enqueueKey()', () => {
it('enqueues keys', () => { it('enqueues keys', () => {
sut.enqueueKey({ key: 'a' }); sut.enqueueKey(Key.fromMapKey('a');
sut.enqueueKey({ key: 'b' }); sut.enqueueKey(Key.fromMapKey('b');
let sequence = sut.enqueueKey({ key: 'c' }); let sequence = sut.enqueueKey(Key.fromMapKey('c'));
expect(sequence.getKeyArray()).deep.equals([ let keys = sequence.getKeyArray();
{ key: 'a' }, { key: 'b' }, { key: 'c' }, expect(keys[0].equals(Key.fromMapKey('a'))).to.be.true;
]); expect(keys[1].equals(Key.fromMapKey('b'))).to.be.true;
expect(keys[2].equals(Key.fromMapKey('c'))).to.be.true;
}); });
}); });
describe('#clear()', () => { describe('#clear()', () => {
it('clears keys', () => { it('clears keys', () => {
sut.enqueueKey({ key: 'a' }); sut.enqueueKey(Key.fromMapKey('a');
sut.enqueueKey({ key: 'b' }); sut.enqueueKey(Key.fromMapKey('b');
sut.enqueueKey({ key: 'c' }); sut.enqueueKey(Key.fromMapKey('c');
sut.clear(); sut.clear();
let sequence = sut.enqueueKey({ key: 'a' }); let sequence = sut.enqueueKey(Key.fromMapKey('a'));
expect(sequence.length()).to.equal(1); expect(sequence.length()).to.equal(1);
}); });
}); });