diff --git a/assets/index.less b/assets/index.less
index 3392a6b5..d434a446 100644
--- a/assets/index.less
+++ b/assets/index.less
@@ -10,32 +10,32 @@
 @effect-duration: 0.3s;
 
 .@{tabs-prefix-cls} {
-  border: 1px solid gray;
-  font-size: 14px;
   overflow: hidden;
+  font-size: 14px;
+  border: 1px solid gray;
 
   // ========================== Navigation ==========================
   &-nav {
+    position: relative;
     display: flex;
     flex: none;
-    position: relative;
 
     &-measure,
     &-wrap {
-      transform: translate(0);
       position: relative;
       display: inline-block;
+      display: flex;
       flex: auto;
-      white-space: nowrap;
       overflow: hidden;
-      display: flex;
+      white-space: nowrap;
+      transform: translate(0);
 
       &-ping-left::before,
       &-ping-right::after {
-        content: '';
         position: absolute;
         top: 0;
         bottom: 0;
+        content: '';
       }
       &-ping-left::before {
         left: 0;
@@ -48,10 +48,10 @@
 
       &-ping-top::before,
       &-ping-bottom::after {
-        content: '';
         position: absolute;
-        left: 0;
         right: 0;
+        left: 0;
+        content: '';
       }
       &-ping-top::before {
         top: 0;
@@ -64,8 +64,8 @@
     }
 
     &-list {
-      display: flex;
       position: relative;
+      display: flex;
       transition: transform 0.3s;
     }
 
@@ -81,36 +81,39 @@
     }
 
     &-more {
-      border: 1px solid blue;
       background: rgba(255, 0, 0, 0.1);
+      border: 1px solid blue;
     }
     &-add {
-      border: 1px solid green;
       background: rgba(0, 255, 0, 0.1);
+      border: 1px solid green;
     }
   }
 
   &-tab {
-    border: 0;
+    position: relative;
+    display: flex;
+    align-items: center;
+    margin: 0;
+    font-weight: lighter;
     font-size: 20px;
     background: rgba(255, 255, 255, 0.5);
-    margin: 0;
-    display: flex;
+    border: 0;
     outline: none;
     cursor: pointer;
-    position: relative;
-    font-weight: lighter;
-    align-items: center;
 
     &-btn,
     &-remove {
-      border: 0;
       background: transparent;
+      border: 0;
     }
 
     &-btn {
       font-weight: inherit;
       line-height: 32px;
+      &:focus {
+        outline: none;
+      }
     }
 
     &-remove {
@@ -120,9 +123,12 @@
     }
 
     &-active {
-      // padding-left: 30px;
       font-weight: bolder;
     }
+
+    &-focus {
+      outline: 1px auto #1677ff;
+    }
   }
 
   &-ink-bar {
diff --git a/docs/examples/basic.tsx b/docs/examples/basic.tsx
index f38970ee..b97a0962 100644
--- a/docs/examples/basic.tsx
+++ b/docs/examples/basic.tsx
@@ -24,15 +24,31 @@ export default () => {
       disabled: true,
       icon: <span>🐼</span>,
     },
+    {
+      label: 'Yo',
+      key: 'yo',
+      children: 'Yo!',
+      icon: <span>👋</span>,
+    },
   ]);
+  const [direction, setDirection] = React.useState<'ltr' | 'rtl'>('ltr');
 
   if (destroy) {
     return null;
   }
 
+  const onTabClick = (key: string) => {
+    console.log('key', key);
+  };
+
   return (
     <React.StrictMode>
-      <Tabs tabBarExtraContent="extra" items={items} />
+      <Tabs
+        tabBarExtraContent="extra"
+        onTabClick={onTabClick}
+        direction={direction}
+        items={items}
+      />
       <button
         type="button"
         onClick={() => {
@@ -56,6 +72,14 @@ export default () => {
       >
         Destroy
       </button>
+      <button
+        type="button"
+        onClick={() => {
+          setDirection(direction === 'ltr' ? 'rtl' : 'ltr');
+        }}
+      >
+        {direction === 'ltr' ? 'rtl' : 'ltr'}
+      </button>
     </React.StrictMode>
   );
 };
diff --git a/package.json b/package.json
index afdba6e6..29d7fe19 100644
--- a/package.json
+++ b/package.json
@@ -50,6 +50,7 @@
     "@rc-component/trigger": "^2.0.0",
     "@testing-library/jest-dom": "^6.1.4",
     "@testing-library/react": "^16.0.1",
+    "@testing-library/user-event": "^14.5.2",
     "@types/classnames": "^2.2.10",
     "@types/enzyme": "^3.10.5",
     "@types/jest": "^29.4.0",
diff --git a/src/TabNavList/TabNode.tsx b/src/TabNavList/TabNode.tsx
index 939bc2cf..d11c34cb 100644
--- a/src/TabNavList/TabNode.tsx
+++ b/src/TabNavList/TabNode.tsx
@@ -1,5 +1,4 @@
 import classNames from 'classnames';
-import KeyCode from 'rc-util/lib/KeyCode';
 import * as React from 'react';
 import type { EditableConfig, Tab } from '../interface';
 import { genDataNodeKey, getRemovable } from '../util';
@@ -9,14 +8,21 @@ export interface TabNodeProps {
   prefixCls: string;
   tab: Tab;
   active: boolean;
+  focus: boolean;
   closable?: boolean;
   editable?: EditableConfig;
   onClick?: (e: React.MouseEvent | React.KeyboardEvent) => void;
   onResize?: (width: number, height: number, left: number, top: number) => void;
   renderWrapper?: (node: React.ReactElement) => React.ReactElement;
   removeAriaLabel?: string;
+  tabCount: number;
+  currentPosition: number;
   removeIcon?: React.ReactNode;
+  onKeyDown: React.KeyboardEventHandler;
+  onMouseDown: React.MouseEventHandler;
+  onMouseUp: React.MouseEventHandler;
   onFocus: React.FocusEventHandler;
+  onBlur: React.FocusEventHandler;
   style?: React.CSSProperties;
 }
 
@@ -25,6 +31,7 @@ const TabNode: React.FC<TabNodeProps> = props => {
     prefixCls,
     id,
     active,
+    focus,
     tab: { key, label, disabled, closeIcon, icon },
     closable,
     renderWrapper,
@@ -32,7 +39,13 @@ const TabNode: React.FC<TabNodeProps> = props => {
     editable,
     onClick,
     onFocus,
+    onBlur,
+    onKeyDown,
+    onMouseDown,
+    onMouseUp,
     style,
+    tabCount,
+    currentPosition,
   } = props;
   const tabPrefix = `${prefixCls}-tab`;
 
@@ -56,40 +69,55 @@ const TabNode: React.FC<TabNodeProps> = props => {
     [label, icon],
   );
 
+  const btnRef = React.useRef<HTMLDivElement>(null);
+
+  React.useEffect(() => {
+    if (focus && btnRef.current) {
+      btnRef.current.focus();
+    }
+  }, [focus]);
+
   const node: React.ReactElement = (
     <div
       key={key}
-      // ref={ref}
       data-node-key={genDataNodeKey(key)}
       className={classNames(tabPrefix, {
         [`${tabPrefix}-with-remove`]: removable,
         [`${tabPrefix}-active`]: active,
         [`${tabPrefix}-disabled`]: disabled,
+        [`${tabPrefix}-focus`]: focus,
       })}
       style={style}
       onClick={onInternalClick}
     >
       {/* Primary Tab Button */}
       <div
+        ref={btnRef}
         role="tab"
         aria-selected={active}
         id={id && `${id}-tab-${key}`}
         className={`${tabPrefix}-btn`}
         aria-controls={id && `${id}-panel-${key}`}
         aria-disabled={disabled}
-        tabIndex={disabled ? null : 0}
+        tabIndex={disabled ? null : active ? 0 : -1}
         onClick={e => {
           e.stopPropagation();
           onInternalClick(e);
         }}
-        onKeyDown={e => {
-          if ([KeyCode.SPACE, KeyCode.ENTER].includes(e.which)) {
-            e.preventDefault();
-            onInternalClick(e);
-          }
-        }}
+        onKeyDown={onKeyDown}
+        onMouseDown={onMouseDown}
+        onMouseUp={onMouseUp}
         onFocus={onFocus}
+        onBlur={onBlur}
       >
+        {focus && (
+          <div
+            aria-live="polite"
+            style={{ width: 0, height: 0, position: 'absolute', overflow: 'hidden', opacity: 0 }}
+          >
+            {`Tab ${currentPosition} of ${tabCount}`}
+          </div>
+        )}
         {icon && <span className={`${tabPrefix}-icon`}>{icon}</span>}
         {label && labelNode}
       </div>
@@ -99,7 +127,7 @@ const TabNode: React.FC<TabNodeProps> = props => {
         <button
           type="button"
           aria-label={removeAriaLabel || 'remove'}
-          tabIndex={0}
+          tabIndex={active ? 0 : -1}
           className={`${tabPrefix}-remove`}
           onClick={e => {
             e.stopPropagation();
diff --git a/src/TabNavList/index.tsx b/src/TabNavList/index.tsx
index e51553af..332974da 100644
--- a/src/TabNavList/index.tsx
+++ b/src/TabNavList/index.tsx
@@ -25,7 +25,7 @@ import type {
   TabSizeMap,
   TabsLocale,
 } from '../interface';
-import { genDataNodeKey, stringify } from '../util';
+import { genDataNodeKey, getRemovable, stringify } from '../util';
 import AddButton from './AddButton';
 import ExtraContent from './ExtraContent';
 import OperationNode from './OperationNode';
@@ -150,7 +150,8 @@ const TabNavList = React.forwardRef<HTMLDivElement, TabNavListProps>((props, ref
   const addSizeValue = getUnitValue(addSize, tabPositionTopOrBottom);
   const operationSizeValue = getUnitValue(operationSize, tabPositionTopOrBottom);
 
-  const needScroll = Math.floor(containerExcludeExtraSizeValue) < Math.floor(tabContentSizeValue + addSizeValue);
+  const needScroll =
+    Math.floor(containerExcludeExtraSizeValue) < Math.floor(tabContentSizeValue + addSizeValue);
   const visibleTabContentValue = needScroll
     ? containerExcludeExtraSizeValue - operationSizeValue
     : containerExcludeExtraSizeValue - addSizeValue;
@@ -296,9 +297,113 @@ const TabNavList = React.forwardRef<HTMLDivElement, TabNavListProps>((props, ref
     }
   });
 
+  // ========================= Focus =========================
+  const [focusKey, setFocusKey] = useState<string>();
+  const [isMouse, setIsMouse] = useState(false);
+
+  const enabledTabs = tabs.filter(tab => !tab.disabled).map(tab => tab.key);
+
+  const onOffset = (offset: number) => {
+    const currentIndex = enabledTabs.indexOf(focusKey || activeKey);
+    const len = enabledTabs.length;
+    const nextIndex = (currentIndex + offset + len) % len;
+    const newKey = enabledTabs[nextIndex];
+    setFocusKey(newKey);
+  };
+
+  const handleKeyDown = (e: React.KeyboardEvent) => {
+    const { code } = e;
+
+    const isRTL = rtl && tabPositionTopOrBottom;
+    const firstEnabledTab = enabledTabs[0];
+    const lastEnabledTab = enabledTabs[enabledTabs.length - 1];
+
+    switch (code) {
+      // LEFT
+      case 'ArrowLeft': {
+        if (tabPositionTopOrBottom) {
+          onOffset(isRTL ? 1 : -1);
+        }
+        break;
+      }
+
+      // RIGHT
+      case 'ArrowRight': {
+        if (tabPositionTopOrBottom) {
+          onOffset(isRTL ? -1 : 1);
+        }
+        break;
+      }
+
+      // UP
+      case 'ArrowUp': {
+        e.preventDefault();
+        if (!tabPositionTopOrBottom) {
+          onOffset(-1);
+        }
+        break;
+      }
+
+      // DOWN
+      case 'ArrowDown': {
+        e.preventDefault();
+        if (!tabPositionTopOrBottom) {
+          onOffset(1);
+        }
+        break;
+      }
+
+      // HOME
+      case 'Home': {
+        e.preventDefault();
+        setFocusKey(firstEnabledTab);
+        break;
+      }
+
+      // END
+      case 'End': {
+        e.preventDefault();
+        setFocusKey(lastEnabledTab);
+        break;
+      }
+
+      // Enter & Space
+      case 'Enter':
+      case 'Space': {
+        e.preventDefault();
+        onTabClick(focusKey, e);
+        break;
+      }
+      // Backspace
+      case 'Backspace':
+      case 'Delete': {
+        const removeIndex = enabledTabs.indexOf(focusKey);
+        const removeTab = tabs.find(tab => tab.key === focusKey);
+        const removable = getRemovable(
+          removeTab?.closable,
+          removeTab?.closeIcon,
+          editable,
+          removeTab?.disabled,
+        );
+        if (removable) {
+          e.preventDefault();
+          e.stopPropagation();
+          editable.onEdit('remove', { key: focusKey, event: e });
+          // when remove last tab, focus previous tab
+          if (removeIndex === enabledTabs.length - 1) {
+            onOffset(-1);
+          } else {
+            onOffset(1);
+          }
+        }
+        break;
+      }
+    }
+  };
+
   // ========================== Tab ==========================
   const tabNodeStyle: React.CSSProperties = {};
-  if (tabPosition === 'top' || tabPosition === 'bottom') {
+  if (tabPositionTopOrBottom) {
     tabNodeStyle[rtl ? 'marginRight' : 'marginLeft'] = tabBarGutter;
   } else {
     tabNodeStyle.marginTop = tabBarGutter;
@@ -317,12 +422,19 @@ const TabNavList = React.forwardRef<HTMLDivElement, TabNavListProps>((props, ref
         closable={tab.closable}
         editable={editable}
         active={key === activeKey}
+        focus={key === focusKey}
         renderWrapper={children}
         removeAriaLabel={locale?.removeAriaLabel}
+        tabCount={enabledTabs.length}
+        currentPosition={i + 1}
         onClick={e => {
           onTabClick(key, e);
         }}
+        onKeyDown={handleKeyDown}
         onFocus={() => {
+          if (!isMouse) {
+            setFocusKey(key);
+          }
           scrollToTab(key);
           doLockAnimation();
           if (!tabsWrapperRef.current) {
@@ -334,6 +446,15 @@ const TabNavList = React.forwardRef<HTMLDivElement, TabNavListProps>((props, ref
           }
           tabsWrapperRef.current.scrollTop = 0;
         }}
+        onBlur={() => {
+          setFocusKey(undefined);
+        }}
+        onMouseDown={() => {
+          setIsMouse(true);
+        }}
+        onMouseUp={() => {
+          setIsMouse(false);
+        }}
       />
     );
   });
@@ -445,6 +566,7 @@ const TabNavList = React.forwardRef<HTMLDivElement, TabNavListProps>((props, ref
       <div
         ref={useComposeRef(ref, containerRef)}
         role="tablist"
+        aria-orientation={tabPositionTopOrBottom ? 'horizontal' : 'vertical'}
         className={classNames(`${prefixCls}-nav`, className)}
         style={style}
         onKeyDown={() => {
diff --git a/tests/__snapshots__/index.test.tsx.snap b/tests/__snapshots__/index.test.tsx.snap
index 7fb34117..e742da9f 100644
--- a/tests/__snapshots__/index.test.tsx.snap
+++ b/tests/__snapshots__/index.test.tsx.snap
@@ -5,6 +5,7 @@ exports[`Tabs.Basic Normal 1`] = `
   class="rc-tabs rc-tabs-top"
 >
   <div
+    aria-orientation="horizontal"
     class="rc-tabs-nav"
     role="tablist"
   >
@@ -25,7 +26,7 @@ exports[`Tabs.Basic Normal 1`] = `
             class="rc-tabs-tab-btn"
             id="rc-tabs-test-tab-light"
             role="tab"
-            tabindex="0"
+            tabindex="-1"
           >
             light
           </div>
@@ -55,7 +56,7 @@ exports[`Tabs.Basic Normal 1`] = `
             class="rc-tabs-tab-btn"
             id="rc-tabs-test-tab-cute"
             role="tab"
-            tabindex="0"
+            tabindex="-1"
           >
             cute
           </div>
@@ -109,6 +110,7 @@ exports[`Tabs.Basic Skip invalidate children 1`] = `
   class="rc-tabs rc-tabs-top"
 >
   <div
+    aria-orientation="horizontal"
     class="rc-tabs-nav"
     role="tablist"
   >
diff --git a/tests/accessibility.test.tsx b/tests/accessibility.test.tsx
new file mode 100644
index 00000000..25081cda
--- /dev/null
+++ b/tests/accessibility.test.tsx
@@ -0,0 +1,271 @@
+import { render } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import React from 'react';
+import type { TabsProps } from '../src';
+import Tabs from '../src';
+
+describe('Tabs.Accessibility', () => {
+  const createTabs = (props: TabsProps = {}) => (
+    <Tabs
+      defaultActiveKey="1"
+      {...props}
+      items={[
+        {
+          key: '1',
+          label: 'Tab1',
+          children: 'Content 1',
+        },
+        {
+          key: '2',
+          label: 'Tab2',
+          children: 'Content 2',
+        },
+        {
+          key: '3',
+          label: 'Tab3',
+          disabled: true,
+          children: 'Content 3',
+        },
+        {
+          key: '4',
+          label: 'Tab4',
+          children: 'Content 4',
+        },
+      ]}
+    />
+  );
+
+  it('should support keyboard navigation', async () => {
+    const user = userEvent.setup();
+    const { getByRole } = render(createTabs());
+
+    const firstTab = getByRole('tab', { name: /Tab1/i });
+    const secondTab = getByRole('tab', { name: /Tab2/i });
+    const fourthTab = getByRole('tab', { name: /Tab4/i });
+
+    await user.tab();
+    expect(firstTab).toHaveFocus();
+
+    await user.keyboard('{ArrowRight}');
+    expect(secondTab.parentElement).toHaveClass('rc-tabs-tab-focus');
+
+    // skip disabled tab
+    await user.keyboard('{ArrowRight}');
+    expect(fourthTab.parentElement).toHaveClass('rc-tabs-tab-focus');
+
+    // cycle to first tab
+    await user.keyboard('{ArrowRight}');
+    expect(firstTab.parentElement).toHaveClass('rc-tabs-tab-focus');
+
+    // cycle to last tab
+    await user.keyboard('{ArrowLeft}');
+    expect(fourthTab.parentElement).toHaveClass('rc-tabs-tab-focus');
+
+    // jump to first tab
+    await user.keyboard('{Home}');
+    expect(firstTab.parentElement).toHaveClass('rc-tabs-tab-focus');
+
+    // jump to last tab
+    await user.keyboard('{End}');
+    expect(fourthTab.parentElement).toHaveClass('rc-tabs-tab-focus');
+  });
+
+  it('should support vertical keyboard navigation', async () => {
+    const user = userEvent.setup();
+    const { getByRole } = render(createTabs({ tabPosition: 'left' }));
+
+    // jump to first tab
+    await user.tab();
+    const firstTab = getByRole('tab', { name: /Tab1/i });
+    expect(firstTab).toHaveFocus();
+
+    // move to second tab
+    await user.keyboard('{ArrowDown}');
+    const secondTab = getByRole('tab', { name: /Tab2/i });
+    expect(secondTab.parentElement).toHaveClass('rc-tabs-tab-focus');
+
+    // move to first tab
+    await user.keyboard('{ArrowUp}');
+    expect(firstTab.parentElement).toHaveClass('rc-tabs-tab-focus');
+  });
+
+  it('should activate tab on Enter/Space', async () => {
+    const onTabClick = jest.fn();
+    const user = userEvent.setup();
+
+    render(createTabs({ onTabClick }));
+
+    // jump to first tab
+    await user.tab();
+
+    // activate tab
+    await user.keyboard(' ');
+    expect(onTabClick).toHaveBeenCalledTimes(1);
+
+    // move focus to second tab
+    await user.keyboard('{ArrowRight}');
+
+    // activate tab
+    await user.keyboard('{Enter}');
+    expect(onTabClick).toHaveBeenCalledTimes(2);
+  });
+
+  it('should not navigate to disabled tabs', async () => {
+    const user = userEvent.setup();
+    const { getByRole } = render(createTabs());
+
+    // jump to first tab
+    await user.tab();
+
+    // should skip disabled tab
+    await user.keyboard('{ArrowRight}');
+    await user.keyboard('{ArrowRight}');
+
+    const fourthTab = getByRole('tab', { name: /Tab4/i });
+    expect(fourthTab.parentElement).toHaveClass('rc-tabs-tab-focus');
+  });
+
+  it('should distinguish between keyboard and mouse navigation', async () => {
+    const user = userEvent.setup();
+    const { getByRole } = render(createTabs());
+
+    const secondTab = getByRole('tab', { name: /Tab2/i });
+    const fourthTab = getByRole('tab', { name: /Tab4/i });
+
+    // mouse click should not add focus style
+    await user.click(secondTab);
+    expect(secondTab.parentElement).not.toHaveClass('rc-tabs-tab-focus');
+
+    // clear focus
+    await user.click(document.body);
+
+    // keyboard navigation should add focus style
+    await user.tab();
+    // default focus active tab
+    expect(secondTab.parentElement).toHaveClass('rc-tabs-tab-focus');
+
+    await user.keyboard('{ArrowRight}');
+    // skip disabled tab
+    expect(fourthTab.parentElement).toHaveClass('rc-tabs-tab-focus');
+  });
+
+  it('should support keyboard delete tab', async () => {
+    const user = userEvent.setup();
+    const Demo = () => {
+      const [items, setItems] = React.useState([
+        {
+          key: '1',
+          label: 'Tab1',
+          children: 'Content 1',
+        },
+        {
+          key: '2',
+          label: 'Tab2',
+          children: 'Content 2',
+        },
+        {
+          key: '3',
+          label: 'Tab3',
+          disabled: true,
+          children: 'Content 3',
+        },
+        {
+          key: '4',
+          label: 'Tab4',
+          children: 'Content 4',
+        },
+      ]);
+      return (
+        <Tabs
+          defaultActiveKey="1"
+          items={items}
+          editable={{
+            onEdit: (type, { key }) => {
+              if (type === 'remove') {
+                setItems(prevItems => prevItems.filter(item => item.key !== key));
+              }
+            },
+          }}
+        />
+      );
+    };
+
+    const { getByRole, queryByRole } = render(<Demo />);
+
+    // focus to first tab
+    await user.tab();
+    const firstTab = getByRole('tab', { name: /Tab1/i });
+    expect(firstTab).toHaveFocus();
+
+    // delete first tab
+    await user.keyboard('{Backspace}');
+    expect(queryByRole('tab', { name: /Tab1/i })).toBeNull();
+
+    // focus should move to next tab
+    const secondTab = getByRole('tab', { name: /Tab2/i });
+    expect(secondTab).toHaveFocus();
+
+    // delete second tab
+    await user.keyboard('{Backspace}');
+    expect(queryByRole('tab', { name: /Tab2/i })).toBeNull();
+
+    // focus should move to next tab
+    const fourthTab = getByRole('tab', { name: /Tab4/i });
+    expect(fourthTab).toHaveFocus();
+
+    // keyboard navigation should work
+    await user.keyboard('{ArrowRight}');
+    expect(fourthTab.parentElement).toHaveClass('rc-tabs-tab-focus');
+  });
+
+  it('should focus previous tab when deleting the last tab', async () => {
+    const user = userEvent.setup();
+    const Demo = () => {
+      const [items, setItems] = React.useState([
+        {
+          key: '1',
+          label: 'Tab1',
+          children: 'Content 1',
+        },
+        {
+          key: '2',
+          label: 'Tab2',
+          children: 'Content 2',
+        },
+        {
+          key: '3',
+          label: 'Tab3',
+          children: 'Content 3',
+        },
+      ]);
+      return (
+        <Tabs
+          defaultActiveKey="2"
+          items={items}
+          editable={{
+            onEdit: (type, { key }) => {
+              if (type === 'remove') {
+                setItems(prevItems => prevItems.filter(item => item.key !== key));
+              }
+            },
+          }}
+        />
+      );
+    };
+
+    const { getByRole, queryByRole } = render(<Demo />);
+
+    await user.tab();
+    const secondTab = getByRole('tab', { name: /Tab2/i });
+    expect(secondTab).toHaveFocus();
+
+    await user.keyboard('{Backspace}');
+    expect(queryByRole('tab', { name: /Tab2/i })).toBeNull();
+
+    await user.keyboard('{Delete}');
+    expect(queryByRole('tab', { name: /Tab3/i })).toBeNull();
+
+    const firstTab = getByRole('tab', { name: /Tab1/i });
+    expect(firstTab).toHaveFocus();
+  });
+});
diff --git a/tests/index.test.tsx b/tests/index.test.tsx
index bb377a73..db5bc7d9 100644
--- a/tests/index.test.tsx
+++ b/tests/index.test.tsx
@@ -1,6 +1,5 @@
 import '@testing-library/dom';
 import { act, fireEvent, render, screen } from '@testing-library/react';
-import KeyCode from 'rc-util/lib/KeyCode';
 import { spyElementPrototypes } from 'rc-util/lib/test/domHook';
 import React from 'react';
 import Tabs from '../src';
@@ -25,6 +24,7 @@ describe('Tabs.Basic', () => {
   const hackOffsetInfo: HackInfo = {};
 
   beforeEach(() => {
+    jest.useFakeTimers();
     Object.keys(hackOffsetInfo).forEach(key => {
       delete hackOffsetInfo[key];
     });
@@ -216,15 +216,6 @@ describe('Tabs.Basic', () => {
         trigger: container =>
           fireEvent.click(container.querySelectorAll('.rc-tabs-tab .rc-tabs-tab-btn')[2]),
       },
-      {
-        name: 'inner button key down',
-        trigger: container =>
-          fireEvent.keyDown(container.querySelectorAll('.rc-tabs-tab .rc-tabs-tab-btn')[2], {
-            which: KeyCode.SPACE,
-            keyCode: KeyCode.SPACE,
-            charCode: KeyCode.SPACE,
-          }),
-      },
     ];
 
     list.forEach(({ name, trigger }) => {